From ee8dcb331ac43f4ce23f2d7ffc14dafd9507ea9c Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Tue, 25 Jun 2013 13:15:48 +0200 Subject: [PATCH] import 64-bit version of MPICH2 for windows --- .../mpich2-win64/include/clog_commset.h | 134 + .../mpich2-win64/include/clog_const.h | 27 + .../mpich2-win64/include/clog_inttypes.h | 31 + .../mpich2-win64/include/clog_uuid.h | 55 + tools/mingw-cross/mpich2-win64/include/mpe.h | 19 + .../mpich2-win64/include/mpe_log.h | 309 ++ .../mpich2-win64/include/mpe_logf.h | 56 + .../mpich2-win64/include/mpe_misc.h | 64 + tools/mingw-cross/mpich2-win64/include/mpi.h | 1271 ++++++++ .../mingw-cross/mpich2-win64/include/mpi.mod | Bin 0 -> 3702 bytes .../mpich2-win64/include/mpi_base.mod | Bin 0 -> 90551 bytes .../mpich2-win64/include/mpi_constants.mod | Bin 0 -> 36141 bytes .../mpich2-win64/include/mpi_sizeofs.mod | Bin 0 -> 8417 bytes .../mingw-cross/mpich2-win64/include/mpicxx.h | 2716 +++++++++++++++++ tools/mingw-cross/mpich2-win64/include/mpif.h | 513 ++++ tools/mingw-cross/mpich2-win64/include/mpio.h | 463 +++ tools/mingw-cross/mpich2-win64/lib/libmpi.a | Bin 0 -> 474252 bytes 17 files changed, 5658 insertions(+) create mode 100644 tools/mingw-cross/mpich2-win64/include/clog_commset.h create mode 100644 tools/mingw-cross/mpich2-win64/include/clog_const.h create mode 100644 tools/mingw-cross/mpich2-win64/include/clog_inttypes.h create mode 100644 tools/mingw-cross/mpich2-win64/include/clog_uuid.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpe.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpe_log.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpe_logf.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpe_misc.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpi.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpi.mod create mode 100644 tools/mingw-cross/mpich2-win64/include/mpi_base.mod create mode 100644 tools/mingw-cross/mpich2-win64/include/mpi_constants.mod create mode 100644 tools/mingw-cross/mpich2-win64/include/mpi_sizeofs.mod create mode 100644 tools/mingw-cross/mpich2-win64/include/mpicxx.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpif.h create mode 100644 tools/mingw-cross/mpich2-win64/include/mpio.h create mode 100644 tools/mingw-cross/mpich2-win64/lib/libmpi.a diff --git a/tools/mingw-cross/mpich2-win64/include/clog_commset.h b/tools/mingw-cross/mpich2-win64/include/clog_commset.h new file mode 100644 index 0000000000..0358ec89c9 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/clog_commset.h @@ -0,0 +1,134 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +#if !defined( _CLOG_COMMSET ) +#define _CLOG_COMMSET + +#include "clog_inttypes.h" +#include "clog_uuid.h" +#include "clog_const.h" + +#define CLOG_CommGID_t CLOG_Uuid_t +#define CLOG_CommLID_t CLOG_int32_t +#define CLOG_ThreadLID_t int +/* +typedef CLOG_Uuid_t CLOG_CommGID_t +typedef CLOG_int32_t CLOG_CommLID_t +typedef int CLOG_ThreadLID_t +*/ + +/* Define CLOG communicator event types used in log_mpi_xxxx.c */ +#define CLOG_COMM_WORLD_CREATE 0 /* MPI_COMM_WORLD creation */ +#define CLOG_COMM_SELF_CREATE 1 /* MPI_COMM_SELF creation */ +#define CLOG_COMM_FREE 10 /* MPI_Comm_free() */ +#define CLOG_COMM_INTRA_CREATE 100 /* intracomm creation */ +#define CLOG_COMM_INTRA_LOCAL 101 /* local intracomm of intercomm */ +#define CLOG_COMM_INTRA_REMOTE 102 /* remote intracomm of intercomm */ +#define CLOG_COMM_INTER_CREATE 1000 /* intercomm creation */ + +/* Define CLOG communicator kind */ +#define CLOG_COMM_KIND_UNKNOWN -1 /* is UNKNOWN */ +#define CLOG_COMM_KIND_INTER 0 /* is intercommunicator */ +#define CLOG_COMM_KIND_INTRA 1 /* is intracommunicator */ +#define CLOG_COMM_KIND_LOCAL 2 /* is local intracommunicator */ +#define CLOG_COMM_KIND_REMOTE 3 /* is remote intracommunicator */ + +/* Some CLOG communicator internal constant */ +#define CLOG_COMM_TABLE_INCRE 10 +#define CLOG_COMM_LID_NULL -999999999 +#define CLOG_COMM_RANK_NULL -1 +#define CLOG_COMM_WRANK_NULL -1 +#define CLOG_COMM_TAG_START 100000 + +#if !defined( CLOG_NOMPI ) +#include "mpi.h" +#else +/* + To avoid mpi_null.h from being exposed to the user's include_dir, + the definition of MPI_Comm has to match that in mpi_null.h. + The "#if !defined( _MPI_NULL_MPI_COMM )" is to avoid duplicated + definition of MPI_Comm when both mpi_null.h and this .h are used + in the same .c file. +*/ +#if !defined( _MPI_NULL_MPI_COMM ) +#define _MPI_NULL_MPI_COMM +typedef int MPI_Comm; +#endif +#endif /* Endof if !defined( CLOG_NOMPI ) */ + +typedef struct CLOG_CommIDs_t_ { + CLOG_CommGID_t global_ID; /* global comm ID */ + CLOG_CommLID_t local_ID; /* local comm ID */ + CLOG_int32_t kind; /* value = CLOG_COMM_KIND_xxxx */ + int world_rank; /* rank in MPI_COMM_WORLD */ + int comm_rank; /* rank of comm labelled by global_ID */ + MPI_Comm comm; + struct CLOG_CommIDs_t_ *next; /* related CLOG_CommIDs_t* */ +} CLOG_CommIDs_t; + +/* Definition for CLOG Communicator control data structure */ +typedef struct { + int LID_key; + int world_size; /* size returned by MPI_Comm_size */ + int world_rank; /* rank returned by MPI_Comm_rank */ + unsigned int max; + CLOG_CommLID_t count; + CLOG_CommIDs_t *table; + CLOG_CommIDs_t *IDs4world; + CLOG_CommIDs_t *IDs4self; +} CLOG_CommSet_t; + +#if defined(__cplusplus) +extern "C" { +#endif + +CLOG_CommSet_t* CLOG_CommSet_create( void ); + +void CLOG_CommSet_free( CLOG_CommSet_t **comm_handle ); + +#if defined( CLOG_IMPL ) +void CLOG_CommSet_add_GID( CLOG_CommSet_t *commset, + const CLOG_CommGID_t commgid ); + +void CLOG_CommSet_append_GIDs( CLOG_CommSet_t *parent_commset, + int child_table_count, + const CLOG_CommIDs_t *child_table ); + +CLOG_BOOL_T CLOG_CommSet_sync_IDs( CLOG_CommSet_t *parent_commset, + int child_table_count, + const CLOG_CommIDs_t *child_table ); +#endif + +void CLOG_CommSet_init( CLOG_CommSet_t *commset ); + +const CLOG_CommIDs_t* CLOG_CommSet_add_intracomm( CLOG_CommSet_t *commset, + MPI_Comm comm ); + +const CLOG_CommIDs_t* +CLOG_CommSet_add_intercomm( CLOG_CommSet_t *commset, + MPI_Comm intercomm, + const CLOG_CommIDs_t *intracommIDs ); + +CLOG_CommLID_t CLOG_CommSet_get_LID( CLOG_CommSet_t *commset, MPI_Comm comm ); + +const CLOG_CommIDs_t* CLOG_CommSet_get_IDs( CLOG_CommSet_t *commset, + MPI_Comm comm ); + +void CLOG_CommSet_merge( CLOG_CommSet_t *commset ); + +#if defined( CLOG_IMPL ) +int CLOG_CommSet_write( const CLOG_CommSet_t *commset, int fd, + CLOG_BOOL_T do_byte_swap ); + +int CLOG_CommSet_read( CLOG_CommSet_t *commset, int fd, + CLOG_BOOL_T do_byte_swap ); + +void CLOG_CommSet_print( CLOG_CommSet_t *commset, FILE *stream ); +#endif + +#if defined(__cplusplus) +} +#endif + +#endif /* of _CLOG_COMMSET */ diff --git a/tools/mingw-cross/mpich2-win64/include/clog_const.h b/tools/mingw-cross/mpich2-win64/include/clog_const.h new file mode 100644 index 0000000000..c75dbc724b --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/clog_const.h @@ -0,0 +1,27 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +#if !defined( _CLOG_CONST ) +#define _CLOG_CONST + +/* + CLOG_FILE_TYPE determines default CLOG2 file extension, i.e. ".clog2" + as well as the prefix for the local temporary clog2 file. +*/ +#define CLOG_FILE_TYPE "clog2" + +#define CLOG_BOOL_T int +#define CLOG_BOOL_NULL -1 +#define CLOG_BOOL_FALSE 0 +#define CLOG_BOOL_TRUE 1 + +#define CLOG_PATH_STRLEN 256 +#define CLOG_ERR_STRLEN 256 + +#define CLOG_PROCID_NULL -1 +#define CLOG_NULL_FILE -5 + +#define CLOG_MAXTIME 100000000.0 /* later than all times */ + +#endif /* of _CLOG_CONST */ diff --git a/tools/mingw-cross/mpich2-win64/include/clog_inttypes.h b/tools/mingw-cross/mpich2-win64/include/clog_inttypes.h new file mode 100644 index 0000000000..0a29099682 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/clog_inttypes.h @@ -0,0 +1,31 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +/* + MPE Logging's generated header file for fixed size integer types + and their printf format specifiers used in CLOG2. +*/ +#if !defined( _CLOG_INTTYPES ) +#define _CLOG_INTTYPES + +/* #include */ +/* #include */ + +typedef __int8 CLOG_int8_t; +typedef __int16 CLOG_int16_t; +typedef __int32 CLOG_int32_t; +typedef __int64 CLOG_int64_t; + +/* + Define address-sized integer for the use of MPI_Comm_xxx_attr + in clog2_commset.c. +*/ +typedef __int32 CLOG_Pint; + +#define i8fmt "%hhd" +#define i16fmt "%hd" +#define i32fmt "%ld" +#define i64fmt "%lld" + +#endif diff --git a/tools/mingw-cross/mpich2-win64/include/clog_uuid.h b/tools/mingw-cross/mpich2-win64/include/clog_uuid.h new file mode 100644 index 0000000000..0394294594 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/clog_uuid.h @@ -0,0 +1,55 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +#if !defined( _CLOG_UUID ) +#define _CLOG_UUID + +#include "clog_inttypes.h" +/* + Only CLOG_UUID_NAME_SIZE-1 is useful. + The last char in CLOG_UUID_NAME_SIZE is NULL char, + the terminating character. +#define CLOG_UUID_NAME_SIZE 17 +#define CLOG_UUID_SIZE sizeof(CLOG_int32_t)+sizeof(double)+CLOG_UUID_NAME_SIZE-1 + +typedef struct { + CLOG_int32_t rand; + double time; + char name[CLOG_UUID_NAME_SIZE]; +} CLOG_Uuid_t; +*/ +#define CLOG_UUID_NAME_SIZE 20 +#define CLOG_UUID_SIZE sizeof(CLOG_int32_t) + sizeof(double) \ + + CLOG_UUID_NAME_SIZE + +/* size of string representation of CLOG_Uuit_t */ +#define CLOG_UUID_STR_SIZE 80 + +#if defined(__cplusplus) +extern "C" { +#endif + +typedef char CLOG_Uuid_t[ CLOG_UUID_SIZE ]; + +void CLOG_Uuid_init( void ); + +void CLOG_Uuid_finalize( void ); + +void CLOG_Uuid_generate( CLOG_Uuid_t uuid ); + +void CLOG_Uuid_sprint( CLOG_Uuid_t uuid, char *str ); + +int CLOG_Uuid_is_equal( const CLOG_Uuid_t uuid1, const CLOG_Uuid_t uuid2 ); + +int CLOG_Uuid_compare( const void *obj1, const void *obj2 ); + +void CLOG_Uuid_copy( const CLOG_Uuid_t src_uuid, CLOG_Uuid_t dest_uuid ); + +void CLOG_Uuid_swap_bytes( CLOG_Uuid_t uuid ); + +#if defined(__cplusplus) +} +#endif + +#endif /* of _CLOG_UUID */ diff --git a/tools/mingw-cross/mpich2-win64/include/mpe.h b/tools/mingw-cross/mpich2-win64/include/mpe.h new file mode 100644 index 0000000000..652b74da06 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpe.h @@ -0,0 +1,19 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +/* + MPE_Graphics should not be included here in case the system does not + support the graphics features. +*/ + +#ifndef _MPE_INCLUDE +#define _MPE_INCLUDE + +#include "mpe_misc.h" +#include "mpe_log.h" +#ifdef MPE_GRAPHICS +#include "mpe_graphics.h" +#endif + +#endif diff --git a/tools/mingw-cross/mpich2-win64/include/mpe_log.h b/tools/mingw-cross/mpich2-win64/include/mpe_log.h new file mode 100644 index 0000000000..43eb11960c --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpe_log.h @@ -0,0 +1,309 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +#ifndef _MPE_LOG_H_ +#define _MPE_LOG_H_ + +#ifdef HAVE_WINDOWS_H +#ifdef USE_MPE_STATIC_LIBRARY +# define MPEU_DLL_SPEC +#else +# ifdef MPE_EXPORTS +# define MPEU_DLL_SPEC __declspec(dllexport) +# else +# define MPEU_DLL_SPEC __declspec(dllimport) +# endif +#endif +#else +# define MPEU_DLL_SPEC +#endif + +/* + Constants, MPE_Log_XXX, are for backward compatibility reasons. + MPE is currently returning MPE_LOG_XXX status. +*/ +/* function return values */ +#define MPE_LOG_OK 0 +#define MPE_Log_OK MPE_LOG_OK + /* no problems */ +#define MPE_LOG_LOCKED_OUT 1 +#define MPE_Log_LOCKED_OUT MPE_LOG_LOCKED_OUT + /* logs are being worked on, cannot insert any new entries */ +#define MPE_LOG_NO_MEMORY 2 +#define MPE_Log_NO_MEMORY MPE_LOG_NO_MEMORY + /* could not allocate memory for logging data */ +#define MPE_LOG_FILE_PROB 3 +#define MPE_Log_FILE_PROB MPE_LOG_FILE_PROB + /* cound not open file for writing out the logged info */ +#define MPE_LOG_NOT_INITIALIZED 4 +#define MPE_Log_NOT_INITIALIZED MPE_LOG_NOT_INITIALIZED + /* logging not initialized */ +#define MPE_LOG_PACK_FAIL 5 +#define MPE_Log_PACK_FAIL MPE_LOG_PACK_FAIL + +#if !defined( CLOG_NOMPI ) +#include "mpi.h" +#else +/* + To avoid mpi_null.h from being exposed to the user's include_dir, + the definition of MPI_Comm has to match that in mpi_null.h. + The "#if !defined( _MPI_NULL_MPI_COMM )" is to avoid duplicated + definition of MPI_Comm when both mpi_null.h and this .h are used + in the same .c file. +*/ +#if !defined( _MPI_NULL_MPI_COMM ) +#define _MPI_NULL_MPI_COMM +typedef int MPI_Comm; +#endif +#endif /* Endof if !defined( CLOG_NOMPI ) */ + +#include "clog_commset.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +/* call before calling any other logging functions */ +int MPE_Init_log( void ); + +int MPE_Initialized_logging( void ); + +/* create state with byte info data description lines in MPI_Comm */ +int MPE_Describe_comm_state( MPI_Comm comm, + int state_startID, int state_finalID, + const char *name, const char *color, + const char *format ); + +/* create state with byte info data description lines in MPI_COMM_WORLD */ +int MPE_Describe_info_state( int state_startID, int state_finalID, + const char *name, const char *color, + const char *format ); + +/* Internal MPE routine for MPI logging in MPI_Comm */ +int MPE_Describe_known_state( const CLOG_CommIDs_t *commIDs, int local_thread, + int stateID, int state_startID, int state_finalID, + const char *name, const char *color, + const char *format ); + +/* create state description lines in MPI_COMM_WORLD */ +int MPE_Describe_state( int state_startID, int state_finalID, + const char *name, const char *color ); + +/* create event with byte info data description lines in MPI_comm */ +int MPE_Describe_comm_event( MPI_Comm comm, int eventID, + const char *name, const char *color, + const char *format ); + +/* create event with byte info data description lines in MPI_COMM_WORLD */ +int MPE_Describe_info_event( int eventID, + const char *name, const char *color, + const char *format ); + +/* Internal MPE routine for MPI logging in MPI_Eventm */ +int MPE_Describe_known_event( const CLOG_CommIDs_t *commIDs, int local_thread, + int eventID, + const char *name, const char *color, + const char *format ); + +/* create event description lines in MPI_COMM_WORLD */ +int MPE_Describe_event( int eventID, + const char *name, const char *color ); + +/* fetch new user-space event number(s) */ +int MPE_Log_get_event_number( void ); +int MPE_Log_get_state_eventIDs( int *statedef_startID, + int *statedef_finalID ); +int MPE_Log_get_solo_eventID( int *eventdef_eventID ); + +/* Internal MPE routine for MPI logging */ + +/* fetch a new known event ID of state for MPE Logging system */ +int MPE_Log_get_known_eventID( void ); +/* fetch a new known state ID for MPE Logging system */ +int MPE_Log_get_known_stateID( void ); +/* fetch a new known solo event ID for MPE Logging system */ +int MPE_Log_get_known_solo_eventID( void ); + +/* log a MPI_Comm creation/destruction event */ +int MPE_Log_commIDs_intracomm( const CLOG_CommIDs_t *commIDs, int local_thread, + int comm_etype, + const CLOG_CommIDs_t *intracommIDs ); +int MPE_Log_commIDs_nullcomm( const CLOG_CommIDs_t *commIDs, int local_thread, + int comm_etype ); +int MPE_Log_commIDs_intercomm( const CLOG_CommIDs_t *commIDs, int local_thread, + int comm_etype, + const CLOG_CommIDs_t *intercommIDs ); + +/* log the sending of a message in MPI_Comm */ +int MPE_Log_commIDs_send( const CLOG_CommIDs_t *commIDs, int local_thread, + int receiver, int tag, int size ); +int MPE_Log_comm_send( MPI_Comm comm, int receiver, int tag, int size ); + +/* log the sending of a message in MPI_COMM_WORLD */ +int MPE_Log_send( int receiver, int tag, int size ); + +/* log the receiving of a message in MPI_Comm */ +int MPE_Log_commIDs_receive( const CLOG_CommIDs_t *commIDs, int local_thread, + int sender, int tag, int size ); +int MPE_Log_comm_receive( MPI_Comm comm, int sender, int tag, int size ); + +/* log the receiving of a message in MPI_COMM_WORLD */ +int MPE_Log_receive( int sender, int tag, int size ); + +/* MPE_LOG_BYTESIZE is equal to sizeof(CLOG_BYTES) defined in clog.h */ +#define MPE_LOG_BYTESIZE (4 * sizeof(double)) +typedef char MPE_LOG_BYTES[ MPE_LOG_BYTESIZE ]; + +int MPE_Log_pack( MPE_LOG_BYTES bytebuf, int *position, + char tokentype, int count, const void *data ); + +int MPE_Log_commIDs_event( const CLOG_CommIDs_t *commIDs, int local_thread, + int event, const char *bytebuf ); + +/* log an event in MPI_Comm */ +int MPE_Log_comm_event( MPI_Comm comm, int event, const char *bytebuf ); + + +/* log an event in MPI_COMM_WORLD */ +int MPE_Log_event( int event, int data, const char *bytebuf ); + +/* log a bare event in MPI_COMM_WORLD */ +int MPE_Log_bare_event( int event ); + +/* log an infomational event in MPI_COMM_WORLD */ +int MPE_Log_info_event( int event, const char *bytebuf ); + +int MPE_Log_sync_clocks( void ); + +/* start logging events */ +int MPE_Start_log( void ); + +/* stop logging events */ +int MPE_Stop_log( void ); + +/* Synchronize thread related data to all processes */ +void MPE_Log_thread_sync( int local_thread_count ); + +/* write out data to a file */ +int MPE_Finish_log( const char *filename ); + +/* get the immutable merged logfile name */ +const char* MPE_Log_merged_logfilename( void ); + +#if defined(__cplusplus) +} +#endif + +#endif + + + +/* + The following documentation has little resemblance to current CLOG-2 + format. They are kept here for historical reference purpose. + 2/17/2005 Anthony Chan +*/ +/* +The format: + +Each line: + type process task data cycle timestamp [comment] + + type - nonnegative integer representing a user-defined event type + process - an integer representing the process in which the event occurred + task - an integer representing a different notion of task. Usually + ignored. + data - an integer representing user data for the event + cycle - an integer representing a time cycle, used to distinguish + between time returned by a timer that "rolls over" during + the run + timestamp - an integer representing (when considered in conjuction + with the cycle number) a time for the event. Upshot treats + the units as microseconds + comment - an optional character string representing user data. Currently + 12 character maximum, will soon hopefully be any length (really!) + +All events from -100 to -1 are reserved header information events. When +a log is produced, all [-100,-1] events will be moved to the top of the +logfile and have their timestamps set to 0. + +All event from -101 and below are reserved system events. This is to +provide some standardization for the logfiles, so various interpreting +programs can glean similar data from the same logfile. All [-101,...) +events will have valid timestamps and will be left in time-sorted +order in the logfile. + +Formats for reserved types: + + -1 Creation data *not used* + Comment: Creator and date + + -2 Number of events in the logfile *not used* + Data: number of events + + -3 Number of processors in the run + Data: number of processes + + -4 Number of tasks used in the run *not used* + Task: number of tasks + + -5 Number of event types used *not used* + Data: number event types + + -6 Start time of the run + Timestamp: start time + + -7 End time of the run + Timestamp: end time + + -8 Number of times the timer cycled + For example, if the timer's units are in microseconds, and it has a + range of 0 - 2^32, and a run lasts 3 hours (range=4294 seconds, 3 hours= + 10800 seconds), the timer would have cycled at least twice. + Data: number of timer cycles + + -9 Decription of event types *not used* + Data: event type + Comment: Description + + -10 printf string for event types *not used* + Data: event type + Comment: printf string + + -11 Rollover point + The point at which the timer values 'rollover' + Timestamp: rollover point + + -13 State definition + Define a state based on the events that signal the beginning and end + of the state. Also, define what to call the state and what color/ + stipple pattern to give it in a graphical visualization tool. + Task: start event + Data: end event + Comment: color:bitmap state name + + example: -13 0 3 4 0 0 Green:boxes Rhode Island + An event with type 3 will signify the entrance into a 'Rhode Island' + state. An event wil type 4 will signify the exit of the 'Rhode Island' + state. + + States may be overlapped (enter a 'Rhode Island' state while in a + 'Wisconsin' state while in a 'Nevada' state), and the state name may + have whitspace in it. + + -100 Synchronization event + Sync events are used internally to sychronize timers on the various + processes. They do not appear in the logfiles. + + -101 Send message + Represents the sending of a message + Data: process ID of the receiving process + Comment: + + -102 Receive message + Represents the receiving of a message + Data: process ID of the sending process + Comment: + +*/ diff --git a/tools/mingw-cross/mpich2-win64/include/mpe_logf.h b/tools/mingw-cross/mpich2-win64/include/mpe_logf.h new file mode 100644 index 0000000000..0fba2f27a2 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpe_logf.h @@ -0,0 +1,56 @@ +! /* -*- Mode: Fortran; -*- */ +! +! (C) 2001 by Argonne National Laboratory. +! See COPYRIGHT in top-level directory. +! +! +! +! MPE Logging Return Codes +! + integer MPE_LOG_OK, MPE_LOG_LOCKED_OUT + parameter ( MPE_LOG_OK = 0, MPE_LOG_LOCKED_OUT = 1 ) + integer MPE_LOG_NO_MEMORY, MPE_LOG_FILE_PROB + parameter ( MPE_LOG_NO_MEMORY = 2, MPE_LOG_FILE_PROB = 3 ) + integer MPE_LOG_NOT_INITIALIZED, MPE_LOG_PACK_FAIL + parameter ( MPE_LOG_NOT_INITIALIZED = 4, MPE_LOG_PACK_FAIL = 5 ) +! +! MPE Logging Function Prototypes +! + integer MPE_Init_log + external MPE_Init_log + integer MPE_Initialized_logging + external MPE_Initialized_logging + integer MPE_Describe_info_state + external MPE_Describe_info_state + integer MPE_Describe_state + external MPE_Describe_state + integer MPE_Describe_info_event + external MPE_Describe_info_event + integer MPE_Describe_event + external MPE_Describe_event + integer MPE_Log_get_event_number + external MPE_Log_get_event_number + integer MPE_Log_get_state_eventIDs + external MPE_Log_get_state_eventIDs + integer MPE_Log_get_solo_eventID + external MPE_Log_get_solo_eventID + integer MPE_Start_log + external MPE_Start_log + integer MPE_Log_send + external MPE_Log_send + integer MPE_Log_receive + external MPE_Log_receive + integer MPE_Log_pack + external MPE_Log_pack + integer MPE_Log_event + external MPE_Log_event + integer MPE_Log_bare_event + external MPE_Log_bare_event + integer MPE_Log_info_event + external MPE_Log_info_event + external MPE_Log_sync_clocks + integer MPE_Log_sync_clocks + integer MPE_Stop_log + external MPE_Stop_log + integer MPE_Finish_log + external MPE_Finish_log diff --git a/tools/mingw-cross/mpich2-win64/include/mpe_misc.h b/tools/mingw-cross/mpich2-win64/include/mpe_misc.h new file mode 100644 index 0000000000..560f3bcec8 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpe_misc.h @@ -0,0 +1,64 @@ +/* + (C) 2001 by Argonne National Laboratory. + See COPYRIGHT in top-level directory. +*/ +/* + MPE Miscellaneous routine headers +*/ + +#ifndef _MPE_MISC +#define _MPE_MISC + + +#ifndef MPE_NOMPI +#include "mpi.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +void MPE_Seq_begin ( MPI_Comm, int ); +void MPE_Seq_end ( MPI_Comm, int ); + +int MPE_DelTag ( MPI_Comm, int, void *, void * ); +int MPE_GetTags ( MPI_Comm, int, MPI_Comm *, int * ); +int MPE_ReturnTags ( MPI_Comm, int, int ); +int MPE_TagsEnd ( void ); + +void MPE_IO_Stdout_to_file ( char *, int ); + +void MPE_GetHostName ( char *, int ); + +void MPE_Start_debugger ( void ); +void MPE_Errors_call_debugger ( char *, char *, char ** ); +void MPE_Errors_call_xdbx ( char *, char * ); +void MPE_Errors_call_dbx_in_xterm ( char *, char * ); +void MPE_Signals_call_debugger ( void ); + +int MPE_Decomp1d ( int, int, int, int *, int * ); + +void MPE_Comm_global_rank ( MPI_Comm, int, int * ); + +#if defined(__cplusplus) +} +#endif + +#if (defined(__STDC__) || defined(__cplusplus)) +void MPE_Errors_to_dbx ( MPI_Comm *, int *, ... ); +#else +void MPE_Errors_to_dbx ( MPI_Comm *, int *, char *, char *, int * ); +#endif + +#else + +#if defined(__cplusplus) +extern "C" { +#endif +void MPE_GetHostName ( char *, int ); +#if defined(__cplusplus) +} +#endif + +#endif + +#endif diff --git a/tools/mingw-cross/mpich2-win64/include/mpi.h b/tools/mingw-cross/mpich2-win64/include/mpi.h new file mode 100644 index 0000000000..10d729bc1d --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpi.h @@ -0,0 +1,1271 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ +/* + * (C) 2001 by Argonne National Laboratory. + * See COPYRIGHT in top-level directory. + */ +/* @configure_input@ */ +#ifndef MPI_INCLUDED +#define MPI_INCLUDED + +/* user include file for MPI programs */ + +/* Keep C++ compilers from getting confused */ +#if defined(__cplusplus) +extern "C" { +#endif + +/* Results of the compare operations. */ +#define MPI_IDENT 0 +#define MPI_CONGRUENT 1 +#define MPI_SIMILAR 2 +#define MPI_UNEQUAL 3 + +typedef int MPI_Datatype; +#define MPI_CHAR ((MPI_Datatype)0x4c000101) +#define MPI_SIGNED_CHAR ((MPI_Datatype)0x4c000118) +#define MPI_UNSIGNED_CHAR ((MPI_Datatype)0x4c000102) +#define MPI_BYTE ((MPI_Datatype)0x4c00010d) +#define MPI_WCHAR ((MPI_Datatype)0x4c00020e) +#define MPI_SHORT ((MPI_Datatype)0x4c000203) +#define MPI_UNSIGNED_SHORT ((MPI_Datatype)0x4c000204) +#define MPI_INT ((MPI_Datatype)0x4c000405) +#define MPI_UNSIGNED ((MPI_Datatype)0x4c000406) +#define MPI_LONG ((MPI_Datatype)0x4c000407) +#define MPI_UNSIGNED_LONG ((MPI_Datatype)0x4c000408) +#define MPI_FLOAT ((MPI_Datatype)0x4c00040a) +#define MPI_DOUBLE ((MPI_Datatype)0x4c00080b) +#define MPI_LONG_DOUBLE ((MPI_Datatype)0x4c00080c) +#define MPI_LONG_LONG_INT ((MPI_Datatype)0x4c000809) +#define MPI_UNSIGNED_LONG_LONG ((MPI_Datatype)0x4c000819) +#define MPI_LONG_LONG MPI_LONG_LONG_INT + +#define MPI_PACKED ((MPI_Datatype)0x4c00010f) +#define MPI_LB ((MPI_Datatype)0x4c000010) +#define MPI_UB ((MPI_Datatype)0x4c000011) + +/* + The layouts for the types MPI_DOUBLE_INT etc are simply + struct { + double var; + int loc; + } + This is documented in the man pages on the various datatypes. + */ +#define MPI_FLOAT_INT ((MPI_Datatype)0x8c000000) +#define MPI_DOUBLE_INT ((MPI_Datatype)0x8c000001) +#define MPI_LONG_INT ((MPI_Datatype)0x8c000002) +#define MPI_SHORT_INT ((MPI_Datatype)0x8c000003) +#define MPI_2INT ((MPI_Datatype)0x4c000816) +#define MPI_LONG_DOUBLE_INT ((MPI_Datatype)0x8c000004) + +/* Fortran types */ +#define MPI_COMPLEX ((MPI_Datatype)0x4c00081e) +#define MPI_DOUBLE_COMPLEX ((MPI_Datatype)0x4c001022) +#define MPI_LOGICAL ((MPI_Datatype)0x4c00041d) +#define MPI_REAL ((MPI_Datatype)0x4c00041c) +#define MPI_DOUBLE_PRECISION ((MPI_Datatype)0x4c00081f) +#define MPI_INTEGER ((MPI_Datatype)0x4c00041b) +#define MPI_2INTEGER ((MPI_Datatype)0x4c000820) +/* + * MPI_2COMPLEX and MPI_2DOUBLE_COMPLEX were defined by accident in + * MPI 1.0 and removed in MPI 1.1. + * + * This definition provides backward compatibility. These definitions + * will be removed in a subsequent MPICH release + */ +#ifdef MPICH_DEFINE_2COMPLEX +#define MPI_2COMPLEX ((MPI_Datatype)0x4c001024) +#define MPI_2DOUBLE_COMPLEX ((MPI_Datatype)0x4c002025) +#endif +#define MPI_2REAL ((MPI_Datatype)0x4c000821) +#define MPI_2DOUBLE_PRECISION ((MPI_Datatype)0x4c001023) +#define MPI_CHARACTER ((MPI_Datatype)0x4c00011a) + +/* Size-specific types (see MPI-2, 10.2.5) */ +#define MPI_REAL4 ((MPI_Datatype)0x4c000427) +#define MPI_REAL8 ((MPI_Datatype)0x4c000829) +#define MPI_REAL16 ((MPI_Datatype)0x4c00102b) +#define MPI_COMPLEX8 ((MPI_Datatype)0x4c000828) +#define MPI_COMPLEX16 ((MPI_Datatype)0x4c00102a) +#define MPI_COMPLEX32 ((MPI_Datatype)0x4c00202c) +#define MPI_INTEGER1 ((MPI_Datatype)0x4c00012d) +#define MPI_INTEGER2 ((MPI_Datatype)0x4c00022f) +#define MPI_INTEGER4 ((MPI_Datatype)0x4c000430) +#define MPI_INTEGER8 ((MPI_Datatype)0x4c000831) +#define MPI_INTEGER16 ((MPI_Datatype)0x4c001032) + +/* C99 fixed-width datatypes */ +#define MPI_INT8_T ((MPI_Datatype)0x4c000137) +#define MPI_INT16_T ((MPI_Datatype)0x4c000238) +#define MPI_INT32_T ((MPI_Datatype)0x4c000439) +#define MPI_INT64_T ((MPI_Datatype)0x4c00083a) +#define MPI_UINT8_T ((MPI_Datatype)0x4c00013b) +#define MPI_UINT16_T ((MPI_Datatype)0x4c00023c) +#define MPI_UINT32_T ((MPI_Datatype)0x4c00043d) +#define MPI_UINT64_T ((MPI_Datatype)0x4c00083e) + +/* other C99 types */ +#define MPI_C_BOOL ((MPI_Datatype)0x4c00013f) +#define MPI_C_FLOAT_COMPLEX ((MPI_Datatype)0x4c000840) +#define MPI_C_COMPLEX MPI_C_FLOAT_COMPLEX +#define MPI_C_DOUBLE_COMPLEX ((MPI_Datatype)0x4c001041) +#define MPI_C_LONG_DOUBLE_COMPLEX ((MPI_Datatype)0x4c001042) + +/* address/offset types */ +#define MPI_AINT ((MPI_Datatype)0x4c000843) +#define MPI_OFFSET ((MPI_Datatype)0x4c000844) + +/* typeclasses */ +#define MPI_TYPECLASS_REAL 1 +#define MPI_TYPECLASS_INTEGER 2 +#define MPI_TYPECLASS_COMPLEX 3 + +/* Communicators */ +typedef int MPI_Comm; +#define MPI_COMM_WORLD ((MPI_Comm)0x44000000) +#define MPI_COMM_SELF ((MPI_Comm)0x44000001) + +/* Groups */ +typedef int MPI_Group; +#define MPI_GROUP_EMPTY ((MPI_Group)0x48000000) + +/* RMA and Windows */ +typedef int MPI_Win; +#define MPI_WIN_NULL ((MPI_Win)0x20000000) + +/* File and IO */ +/* This define lets ROMIO know that MPI_File has been defined */ +#define MPI_FILE_DEFINED +/* ROMIO uses a pointer for MPI_File objects. This must be the same definition + as in src/mpi/romio/include/mpio.h.in */ +typedef struct ADIOI_FileD *MPI_File; +#define MPI_FILE_NULL ((MPI_File)0) + +/* Collective operations */ +typedef int MPI_Op; + +#define MPI_MAX (MPI_Op)(0x58000001) +#define MPI_MIN (MPI_Op)(0x58000002) +#define MPI_SUM (MPI_Op)(0x58000003) +#define MPI_PROD (MPI_Op)(0x58000004) +#define MPI_LAND (MPI_Op)(0x58000005) +#define MPI_BAND (MPI_Op)(0x58000006) +#define MPI_LOR (MPI_Op)(0x58000007) +#define MPI_BOR (MPI_Op)(0x58000008) +#define MPI_LXOR (MPI_Op)(0x58000009) +#define MPI_BXOR (MPI_Op)(0x5800000a) +#define MPI_MINLOC (MPI_Op)(0x5800000b) +#define MPI_MAXLOC (MPI_Op)(0x5800000c) +#define MPI_REPLACE (MPI_Op)(0x5800000d) + +/* Permanent key values */ +/* C Versions (return pointer to value), + Fortran Versions (return integer value). + Handled directly by the attribute value routine + + DO NOT CHANGE THESE. The values encode: + builtin kind (0x1 in bit 30-31) + Keyval object (0x9 in bits 26-29) + for communicator (0x1 in bits 22-25) + + Fortran versions of the attributes are formed by adding one to + the C version. + */ +#define MPI_TAG_UB 0x64400001 +#define MPI_HOST 0x64400003 +#define MPI_IO 0x64400005 +#define MPI_WTIME_IS_GLOBAL 0x64400007 +#define MPI_UNIVERSE_SIZE 0x64400009 +#define MPI_LASTUSEDCODE 0x6440000b +#define MPI_APPNUM 0x6440000d + +/* In addition, there are 3 predefined window attributes that are + defined for every window */ +#define MPI_WIN_BASE 0x66000001 +#define MPI_WIN_SIZE 0x66000003 +#define MPI_WIN_DISP_UNIT 0x66000005 + +/* Define some null objects */ +#define MPI_COMM_NULL ((MPI_Comm)0x04000000) +#define MPI_OP_NULL ((MPI_Op)0x18000000) +#define MPI_GROUP_NULL ((MPI_Group)0x08000000) +#define MPI_DATATYPE_NULL ((MPI_Datatype)0x0c000000) +#define MPI_REQUEST_NULL ((MPI_Request)0x2c000000) +#define MPI_ERRHANDLER_NULL ((MPI_Errhandler)0x14000000) + +/* These are only guesses; make sure you change them in mpif.h as well */ +#define MPI_MAX_PROCESSOR_NAME 128 +#define MPI_MAX_ERROR_STRING 1024 +#define MPI_MAX_PORT_NAME 256 +#define MPI_MAX_OBJECT_NAME 128 + +/* Pre-defined constants */ +#define MPI_UNDEFINED (-32766) +#define MPI_KEYVAL_INVALID 0x24000000 + +/* Upper bound on the overhead in bsend for each message buffer */ +#define MPI_BSEND_OVERHEAD 95 + +/* keyval for COMM_WORLD attribute holding list of failed processes */ +extern int MPICH_ATTR_FAILED_PROCESSES; + +/* Topology types */ +typedef enum MPIR_Topo_type { MPI_GRAPH=1, MPI_CART=2, MPI_DIST_GRAPH=3 } MPIR_Topo_type; + +#define MPI_BOTTOM (void *)0 +#define MPI_UNWEIGHTED ((int *)0) + +#define MPI_PROC_NULL (-1) +#define MPI_ANY_SOURCE (-2) +#define MPI_ROOT (-3) +#define MPI_ANY_TAG (-1) + +#define MPI_LOCK_EXCLUSIVE 234 +#define MPI_LOCK_SHARED 235 + +/* C functions */ +typedef void (MPI_Handler_function) ( MPI_Comm *, int *, ... ); +typedef int (MPI_Comm_copy_attr_function)(MPI_Comm, int, void *, void *, + void *, int *); +typedef int (MPI_Comm_delete_attr_function)(MPI_Comm, int, void *, void *); +typedef int (MPI_Type_copy_attr_function)(MPI_Datatype, int, void *, void *, + void *, int *); +typedef int (MPI_Type_delete_attr_function)(MPI_Datatype, int, void *, void *); +typedef int (MPI_Win_copy_attr_function)(MPI_Win, int, void *, void *, void *, + int *); +typedef int (MPI_Win_delete_attr_function)(MPI_Win, int, void *, void *); +/* added in MPI-2.2 */ +typedef void (MPI_Comm_errhandler_function)(MPI_Comm *, int *, ...); +typedef void (MPI_File_errhandler_function)(MPI_File *, int *, ...); +typedef void (MPI_Win_errhandler_function)(MPI_Win *, int *, ...); +/* names that were added in MPI-2.0 and deprecated in MPI-2.2 */ +typedef MPI_Comm_errhandler_function MPI_Comm_errhandler_fn; +typedef MPI_File_errhandler_function MPI_File_errhandler_fn; +typedef MPI_Win_errhandler_function MPI_Win_errhandler_fn; + +/* Built in (0x1 in 30-31), errhandler (0x5 in bits 26-29, allkind (0 + in 22-25), index in the low bits */ +#define MPI_ERRORS_ARE_FATAL ((MPI_Errhandler)0x54000000) +#define MPI_ERRORS_RETURN ((MPI_Errhandler)0x54000001) +/* MPIR_ERRORS_THROW_EXCEPTIONS is not part of the MPI standard, it is here to + facilitate the c++ binding which has MPI::ERRORS_THROW_EXCEPTIONS. + Using the MPIR prefix preserved the MPI_ names for objects defined by + the standard. */ +#define MPIR_ERRORS_THROW_EXCEPTIONS ((MPI_Errhandler)0x54000002) +typedef int MPI_Errhandler; + +/* Make the C names for the dup function mixed case. + This is required for systems that use all uppercase names for Fortran + externals. */ +/* MPI 1 names */ +#define MPI_NULL_COPY_FN ((MPI_Copy_function *)0) +#define MPI_NULL_DELETE_FN ((MPI_Delete_function *)0) +#define MPI_DUP_FN MPIR_Dup_fn +/* MPI 2 names */ +#define MPI_COMM_NULL_COPY_FN ((MPI_Comm_copy_attr_function*)0) +#define MPI_COMM_NULL_DELETE_FN ((MPI_Comm_delete_attr_function*)0) +#define MPI_COMM_DUP_FN ((MPI_Comm_copy_attr_function *)MPI_DUP_FN) +#define MPI_WIN_NULL_COPY_FN ((MPI_Win_copy_attr_function*)0) +#define MPI_WIN_NULL_DELETE_FN ((MPI_Win_delete_attr_function*)0) +#define MPI_WIN_DUP_FN ((MPI_Win_copy_attr_function*)MPI_DUP_FN) +#define MPI_TYPE_NULL_COPY_FN ((MPI_Type_copy_attr_function*)0) +#define MPI_TYPE_NULL_DELETE_FN ((MPI_Type_delete_attr_function*)0) +#define MPI_TYPE_DUP_FN ((MPI_Type_copy_attr_function*)MPI_DUP_FN) + +/* MPI request opjects */ +typedef int MPI_Request; + +/* User combination function */ +typedef void (MPI_User_function) ( void *, void *, int *, MPI_Datatype * ); + +/* MPI Attribute copy and delete functions */ +typedef int (MPI_Copy_function) ( MPI_Comm, int, void *, void *, void *, int * ); +typedef int (MPI_Delete_function) ( MPI_Comm, int, void *, void * ); + +#define MPI_VERSION 2 +#define MPI_SUBVERSION 2 +#define MPICH_NAME 2 +#define MPICH2 1 +#define MPICH_HAS_C2F 1 + + +/* MPICH2_VERSION is the version string. MPICH2_NUMVERSION is the + * numeric version that can be used in numeric comparisons. + * + * MPICH2_VERSION uses the following format: + * Version: [MAJ].[MIN].[REV][EXT][EXT_NUMBER] + * Example: 1.0.7rc1 has + * MAJ = 1 + * MIN = 0 + * REV = 7 + * EXT = rc + * EXT_NUMBER = 1 + * + * MPICH2_NUMVERSION will convert EXT to a format number: + * ALPHA (a) = 0 + * BETA (b) = 1 + * RC (rc) = 2 + * PATCH (p) = 3 + * Regular releases are treated as patch 0 + * + * Numeric version will have 1 digit for MAJ, 2 digits for MIN, 2 + * digits for REV, 1 digit for EXT and 2 digits for EXT_NUMBER. So, + * 1.0.7rc1 will have the numeric version 10007201. + */ +#define MPICH2_VERSION "1.4.1p1" +#define MPICH2_NUMVERSION 10401301 + +#define MPICH2_RELEASE_TYPE_ALPHA 0 +#define MPICH2_RELEASE_TYPE_BETA 1 +#define MPICH2_RELEASE_TYPE_RC 2 +#define MPICH2_RELEASE_TYPE_PATCH 3 + +#define MPICH2_CALC_VERSION(MAJOR, MINOR, REVISION, TYPE, PATCH) \ + (((MAJOR) * 10000000) + ((MINOR) * 100000) + ((REVISION) * 1000) + ((TYPE) * 100) + (PATCH)) + +/* for the datatype decoders */ +enum MPIR_Combiner_enum { + MPI_COMBINER_NAMED = 1, + MPI_COMBINER_DUP = 2, + MPI_COMBINER_CONTIGUOUS = 3, + MPI_COMBINER_VECTOR = 4, + MPI_COMBINER_HVECTOR_INTEGER = 5, + MPI_COMBINER_HVECTOR = 6, + MPI_COMBINER_INDEXED = 7, + MPI_COMBINER_HINDEXED_INTEGER = 8, + MPI_COMBINER_HINDEXED = 9, + MPI_COMBINER_INDEXED_BLOCK = 10, + MPI_COMBINER_STRUCT_INTEGER = 11, + MPI_COMBINER_STRUCT = 12, + MPI_COMBINER_SUBARRAY = 13, + MPI_COMBINER_DARRAY = 14, + MPI_COMBINER_F90_REAL = 15, + MPI_COMBINER_F90_COMPLEX = 16, + MPI_COMBINER_F90_INTEGER = 17, + MPI_COMBINER_RESIZED = 18 +}; + +/* for info */ +typedef int MPI_Info; +#define MPI_INFO_NULL ((MPI_Info)0x1c000000) +#define MPI_MAX_INFO_KEY 255 +#define MPI_MAX_INFO_VAL 1024 + +/* for subarray and darray constructors */ +#define MPI_ORDER_C 56 +#define MPI_ORDER_FORTRAN 57 +#define MPI_DISTRIBUTE_BLOCK 121 +#define MPI_DISTRIBUTE_CYCLIC 122 +#define MPI_DISTRIBUTE_NONE 123 +#define MPI_DISTRIBUTE_DFLT_DARG -49767 + +#define MPI_IN_PLACE (void *) -1 + +/* asserts for one-sided communication */ +#define MPI_MODE_NOCHECK 1024 +#define MPI_MODE_NOSTORE 2048 +#define MPI_MODE_NOPUT 4096 +#define MPI_MODE_NOPRECEDE 8192 +#define MPI_MODE_NOSUCCEED 16384 + +/* Definitions that are determined by configure. */ +#ifdef MPI_AINT64_TYPE +#undef MPI_AINT64_TYPE +#endif +#if defined(USE_GCC) || defined(__GNUC__) +#define MPI_AINT64_TYPE long long +#else +#define MPI_AINT64_TYPE __int64 +#endif +typedef MPI_AINT64_TYPE MPI_Aint; +#undef MPI_AINT64_TYPE + +typedef int MPI_Fint; +/* FIXME: The following two definition are not defined by MPI and must not be + included in the mpi.h file, as the MPI namespace is reserved to the MPI + standard */ +#define MPI_AINT_FMT_DEC_SPEC "%I64d" +#define MPI_AINT_FMT_HEX_SPEC "%I64x" + +/* Let ROMIO know that MPI_Offset is already defined */ +#define HAVE_MPI_OFFSET +/* MPI_OFFSET_TYPEDEF is set in configure and is + typedef $MPI_OFFSET MPI_Offset; + where $MPI_OFFSET is the correct C type */ +#if defined(USE_GCC) || defined(__GNUC__) +typedef long long MPI_Offset; +#else +typedef __int64 MPI_Offset; +#endif + +/* The order of these elements must match that in mpif.h */ +typedef struct MPI_Status { + int count; + int cancelled; + int MPI_SOURCE; + int MPI_TAG; + int MPI_ERROR; + +} MPI_Status; + +/* Handle conversion types/functions */ + +/* Programs that need to convert types used in MPICH should use these */ +#define MPI_Comm_c2f(comm) (MPI_Fint)(comm) +#define MPI_Comm_f2c(comm) (MPI_Comm)(comm) +#define MPI_Type_c2f(datatype) (MPI_Fint)(datatype) +#define MPI_Type_f2c(datatype) (MPI_Datatype)(datatype) +#define MPI_Group_c2f(group) (MPI_Fint)(group) +#define MPI_Group_f2c(group) (MPI_Group)(group) +#define MPI_Info_c2f(info) (MPI_Fint)(info) +#define MPI_Info_f2c(info) (MPI_Info)(info) +#define MPI_Request_f2c(request) (MPI_Request)(request) +#define MPI_Request_c2f(request) (MPI_Fint)(request) +#define MPI_Op_c2f(op) (MPI_Fint)(op) +#define MPI_Op_f2c(op) (MPI_Op)(op) +#define MPI_Errhandler_c2f(errhandler) (MPI_Fint)(errhandler) +#define MPI_Errhandler_f2c(errhandler) (MPI_Errhandler)(errhandler) +#define MPI_Win_c2f(win) (MPI_Fint)(win) +#define MPI_Win_f2c(win) (MPI_Win)(win) + +/* PMPI versions of the handle transfer functions. See section 4.17 */ +#define PMPI_Comm_c2f(comm) (MPI_Fint)(comm) +#define PMPI_Comm_f2c(comm) (MPI_Comm)(comm) +#define PMPI_Type_c2f(datatype) (MPI_Fint)(datatype) +#define PMPI_Type_f2c(datatype) (MPI_Datatype)(datatype) +#define PMPI_Group_c2f(group) (MPI_Fint)(group) +#define PMPI_Group_f2c(group) (MPI_Group)(group) +#define PMPI_Info_c2f(info) (MPI_Fint)(info) +#define PMPI_Info_f2c(info) (MPI_Info)(info) +#define PMPI_Request_f2c(request) (MPI_Request)(request) +#define PMPI_Request_c2f(request) (MPI_Fint)(request) +#define PMPI_Op_c2f(op) (MPI_Fint)(op) +#define PMPI_Op_f2c(op) (MPI_Op)(op) +#define PMPI_Errhandler_c2f(errhandler) (MPI_Fint)(errhandler) +#define PMPI_Errhandler_f2c(errhandler) (MPI_Errhandler)(errhandler) +#define PMPI_Win_c2f(win) (MPI_Fint)(win) +#define PMPI_Win_f2c(win) (MPI_Win)(win) + +#define MPI_STATUS_IGNORE (MPI_Status *)1 +#define MPI_STATUSES_IGNORE (MPI_Status *)1 +#define MPI_ERRCODES_IGNORE (int *)0 + +/* See 4.12.5 for MPI_F_STATUS(ES)_IGNORE */ +#ifdef USE_MPI_STATIC_LIBRARY +# define MPIU_DLL_SPEC +#else +# ifdef MPI_EXPORTS +# define MPIU_DLL_SPEC __declspec(dllexport) +# else +# define MPIU_DLL_SPEC __declspec(dllimport) +# endif +#endif +#define MPI_CALL __cdecl + +extern MPIU_DLL_SPEC MPI_Fint * MPI_F_STATUS_IGNORE; +extern MPIU_DLL_SPEC MPI_Fint * MPI_F_STATUSES_IGNORE; +/* The annotation MPIU_DLL_SPEC to the extern statements is used + as a hook for systems that require C extensions to correctly construct + DLLs, and is defined as an empty string otherwise + */ + +/* The MPI standard requires that the ARGV_NULL values be the same as + NULL (see 5.3.2) */ +#define MPI_ARGV_NULL (char **)0 +#define MPI_ARGVS_NULL (char ***)0 + +/* For supported thread levels */ +#define MPI_THREAD_SINGLE 0 +#define MPI_THREAD_FUNNELED 1 +#define MPI_THREAD_SERIALIZED 2 +#define MPI_THREAD_MULTIPLE 3 + +/* Typedefs for generalized requests */ +typedef int (MPI_Grequest_cancel_function)(void *, int); +typedef int (MPI_Grequest_free_function)(void *); +typedef int (MPI_Grequest_query_function)(void *, MPI_Status *); + +/* MPI's error classes */ +#define MPI_SUCCESS 0 /* Successful return code */ +/* Communication argument parameters */ +#define MPI_ERR_BUFFER 1 /* Invalid buffer pointer */ +#define MPI_ERR_COUNT 2 /* Invalid count argument */ +#define MPI_ERR_TYPE 3 /* Invalid datatype argument */ +#define MPI_ERR_TAG 4 /* Invalid tag argument */ +#define MPI_ERR_COMM 5 /* Invalid communicator */ +#define MPI_ERR_RANK 6 /* Invalid rank */ +#define MPI_ERR_ROOT 7 /* Invalid root */ +#define MPI_ERR_TRUNCATE 14 /* Message truncated on receive */ + +/* MPI Objects (other than COMM) */ +#define MPI_ERR_GROUP 8 /* Invalid group */ +#define MPI_ERR_OP 9 /* Invalid operation */ +#define MPI_ERR_REQUEST 19 /* Invalid mpi_request handle */ + +/* Special topology argument parameters */ +#define MPI_ERR_TOPOLOGY 10 /* Invalid topology */ +#define MPI_ERR_DIMS 11 /* Invalid dimension argument */ + +/* All other arguments. This is a class with many kinds */ +#define MPI_ERR_ARG 12 /* Invalid argument */ + +/* Other errors that are not simply an invalid argument */ +#define MPI_ERR_OTHER 15 /* Other error; use Error_string */ + +#define MPI_ERR_UNKNOWN 13 /* Unknown error */ +#define MPI_ERR_INTERN 16 /* Internal error code */ + +/* Multiple completion has two special error classes */ +#define MPI_ERR_IN_STATUS 17 /* Look in status for error value */ +#define MPI_ERR_PENDING 18 /* Pending request */ + +/* New MPI-2 Error classes */ +#define MPI_ERR_FILE 27 /* */ +#define MPI_ERR_ACCESS 20 /* */ +#define MPI_ERR_AMODE 21 /* */ +#define MPI_ERR_BAD_FILE 22 /* */ +#define MPI_ERR_FILE_EXISTS 25 /* */ +#define MPI_ERR_FILE_IN_USE 26 /* */ +#define MPI_ERR_NO_SPACE 36 /* */ +#define MPI_ERR_NO_SUCH_FILE 37 /* */ +#define MPI_ERR_IO 32 /* */ +#define MPI_ERR_READ_ONLY 40 /* */ +#define MPI_ERR_CONVERSION 23 /* */ +#define MPI_ERR_DUP_DATAREP 24 /* */ +#define MPI_ERR_UNSUPPORTED_DATAREP 43 /* */ + +/* MPI_ERR_INFO is NOT defined in the MPI-2 standard. I believe that + this is an oversight */ +#define MPI_ERR_INFO 28 /* */ +#define MPI_ERR_INFO_KEY 29 /* */ +#define MPI_ERR_INFO_VALUE 30 /* */ +#define MPI_ERR_INFO_NOKEY 31 /* */ + +#define MPI_ERR_NAME 33 /* */ +#define MPI_ERR_NO_MEM 34 /* Alloc_mem could not allocate memory */ +#define MPI_ERR_NOT_SAME 35 /* */ +#define MPI_ERR_PORT 38 /* */ +#define MPI_ERR_QUOTA 39 /* */ +#define MPI_ERR_SERVICE 41 /* */ +#define MPI_ERR_SPAWN 42 /* */ +#define MPI_ERR_UNSUPPORTED_OPERATION 44 /* */ +#define MPI_ERR_WIN 45 /* */ + +#define MPI_ERR_BASE 46 /* */ +#define MPI_ERR_LOCKTYPE 47 /* */ +#define MPI_ERR_KEYVAL 48 /* Erroneous attribute key */ +#define MPI_ERR_RMA_CONFLICT 49 /* */ +#define MPI_ERR_RMA_SYNC 50 /* */ +#define MPI_ERR_SIZE 51 /* */ +#define MPI_ERR_DISP 52 /* */ +#define MPI_ERR_ASSERT 53 /* */ + +#define MPI_ERR_LASTCODE 0x3fffffff /* Last valid error code for a + predefined error class */ +#define MPICH_ERR_LAST_CLASS 53 /* It is also helpful to know the + last valid class */ +/* End of MPI's error classes */ + +/* Function type defs */ +typedef int (MPI_Datarep_conversion_function)(void *, MPI_Datatype, int, + void *, MPI_Offset, void *); +typedef int (MPI_Datarep_extent_function)(MPI_Datatype datatype, MPI_Aint *, + void *); +#define MPI_CONVERSION_FN_NULL ((MPI_Datarep_conversion_function *)0) + +/* + For systems that may need to add additional definitions to support + different declaration styles and options (e.g., different calling + conventions or DLL import/export controls). +*/ +/* --Insert Additional Definitions Here-- */ + +/* Include any device specific definitions */ +/* No device specific defs */ + +/* + * Normally, we provide prototypes for all MPI routines. In a few weird + * cases, we need to suppress the prototypes. + */ +#ifndef MPICH_SUPPRESS_PROTOTYPES +/* We require that the C compiler support prototypes */ +/* Begin Prototypes */ +int MPI_Send(void*, int, MPI_Datatype, int, int, MPI_Comm); +int MPI_Recv(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *); +int MPI_Get_count(MPI_Status *, MPI_Datatype, int *); +int MPI_Bsend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int MPI_Ssend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int MPI_Rsend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int MPI_Buffer_attach( void*, int); +int MPI_Buffer_detach( void*, int *); +int MPI_Isend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Ibsend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Issend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Irsend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Irecv(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Wait(MPI_Request *, MPI_Status *); +int MPI_Test(MPI_Request *, int *, MPI_Status *); +int MPI_Request_free(MPI_Request *); +int MPI_Waitany(int, MPI_Request *, int *, MPI_Status *); +int MPI_Testany(int, MPI_Request *, int *, int *, MPI_Status *); +int MPI_Waitall(int, MPI_Request *, MPI_Status *); +int MPI_Testall(int, MPI_Request *, int *, MPI_Status *); +int MPI_Waitsome(int, MPI_Request *, int *, int *, MPI_Status *); +int MPI_Testsome(int, MPI_Request *, int *, int *, MPI_Status *); +int MPI_Iprobe(int, int, MPI_Comm, int *, MPI_Status *); +int MPI_Probe(int, int, MPI_Comm, MPI_Status *); +int MPI_Cancel(MPI_Request *); +int MPI_Test_cancelled(MPI_Status *, int *); +int MPI_Send_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int MPI_Bsend_init(void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *); +int MPI_Ssend_init(void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *); +int MPI_Rsend_init(void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *); +int MPI_Recv_init(void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *); +int MPI_Start(MPI_Request *); +int MPI_Startall(int, MPI_Request *); +int MPI_Sendrecv(void *, int, MPI_Datatype,int, int, void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *); +int MPI_Sendrecv_replace(void*, int, MPI_Datatype, int, int, int, int, MPI_Comm, MPI_Status *); +int MPI_Type_contiguous(int, MPI_Datatype, MPI_Datatype *); +int MPI_Type_vector(int, int, int, MPI_Datatype, MPI_Datatype *); +int MPI_Type_hvector(int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *); +int MPI_Type_indexed(int, int *, int *, MPI_Datatype, MPI_Datatype *); +int MPI_Type_hindexed(int, int *, MPI_Aint *, MPI_Datatype, MPI_Datatype *); +int MPI_Type_struct(int, int *, MPI_Aint *, MPI_Datatype *, MPI_Datatype *); +int MPI_Address(void*, MPI_Aint *); +/* We could add __attribute__((deprecated)) to routines like MPI_Type_extent */ +int MPI_Type_extent(MPI_Datatype, MPI_Aint *); +/* See the 1.1 version of the Standard. The standard made an + unfortunate choice here, however, it is the standard. The size returned + by MPI_Type_size is specified as an int, not an MPI_Aint */ +int MPI_Type_size(MPI_Datatype, int *); +/* MPI_Type_count was withdrawn in MPI 1.1 */ +int MPI_Type_lb(MPI_Datatype, MPI_Aint *); +int MPI_Type_ub(MPI_Datatype, MPI_Aint *); +int MPI_Type_commit(MPI_Datatype *); +int MPI_Type_free(MPI_Datatype *); +int MPI_Get_elements(MPI_Status *, MPI_Datatype, int *); +int MPI_Pack(void*, int, MPI_Datatype, void *, int, int *, MPI_Comm); +int MPI_Unpack(void*, int, int *, void *, int, MPI_Datatype, MPI_Comm); +int MPI_Pack_size(int, MPI_Datatype, MPI_Comm, int *); +int MPI_Barrier(MPI_Comm ); +int MPI_Bcast(void*, int, MPI_Datatype, int, MPI_Comm ); +int MPI_Gather(void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int MPI_Gatherv(void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, int, MPI_Comm); +int MPI_Scatter(void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int MPI_Scatterv(void* , int *, int *, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int MPI_Allgather(void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm); +int MPI_Allgatherv(void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm); +int MPI_Alltoall(void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm); +int MPI_Alltoallv(void* , int *, int *, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm); +int MPI_Reduce(void* , void*, int, MPI_Datatype, MPI_Op, int, MPI_Comm); +int MPI_Op_create(MPI_User_function *, int, MPI_Op *); +int MPI_Op_free( MPI_Op *); +int MPI_Allreduce(void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm); +int MPI_Reduce_scatter(void* , void*, int *, MPI_Datatype, MPI_Op, MPI_Comm); +int MPI_Scan(void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm ); +int MPI_Group_size(MPI_Group, int *); +int MPI_Group_rank(MPI_Group, int *); +int MPI_Group_translate_ranks (MPI_Group, int, int *, MPI_Group, int *); +int MPI_Group_compare(MPI_Group, MPI_Group, int *); +int MPI_Comm_group(MPI_Comm, MPI_Group *); +int MPI_Group_union(MPI_Group, MPI_Group, MPI_Group *); +int MPI_Group_intersection(MPI_Group, MPI_Group, MPI_Group *); +int MPI_Group_difference(MPI_Group, MPI_Group, MPI_Group *); +int MPI_Group_incl(MPI_Group, int, int *, MPI_Group *); +int MPI_Group_excl(MPI_Group, int, int *, MPI_Group *); +int MPI_Group_range_incl(MPI_Group, int, int [][3], MPI_Group *); +int MPI_Group_range_excl(MPI_Group, int, int [][3], MPI_Group *); +int MPI_Group_free(MPI_Group *); +int MPI_Comm_size(MPI_Comm, int *); +int MPI_Comm_rank(MPI_Comm, int *); +int MPI_Comm_compare(MPI_Comm, MPI_Comm, int *); +int MPI_Comm_dup(MPI_Comm, MPI_Comm *); +int MPI_Comm_create(MPI_Comm, MPI_Group, MPI_Comm *); +int MPI_Comm_split(MPI_Comm, int, int, MPI_Comm *); +int MPI_Comm_free(MPI_Comm *); +int MPI_Comm_test_inter(MPI_Comm, int *); +int MPI_Comm_remote_size(MPI_Comm, int *); +int MPI_Comm_remote_group(MPI_Comm, MPI_Group *); +int MPI_Intercomm_create(MPI_Comm, int, MPI_Comm, int, int, MPI_Comm * ); +int MPI_Intercomm_merge(MPI_Comm, int, MPI_Comm *); +int MPI_Keyval_create(MPI_Copy_function *, MPI_Delete_function *, int *, void*); +int MPI_Keyval_free(int *); +int MPI_Attr_put(MPI_Comm, int, void*); +int MPI_Attr_get(MPI_Comm, int, void *, int *); +int MPI_Attr_delete(MPI_Comm, int); +int MPI_Topo_test(MPI_Comm, int *); +int MPI_Cart_create(MPI_Comm, int, int *, int *, int, MPI_Comm *); +int MPI_Dims_create(int, int, int *); +int MPI_Graph_create(MPI_Comm, int, int *, int *, int, MPI_Comm *); +int MPI_Graphdims_get(MPI_Comm, int *, int *); +int MPI_Graph_get(MPI_Comm, int, int, int *, int *); +int MPI_Cartdim_get(MPI_Comm, int *); +int MPI_Cart_get(MPI_Comm, int, int *, int *, int *); +int MPI_Cart_rank(MPI_Comm, int *, int *); +int MPI_Cart_coords(MPI_Comm, int, int, int *); +int MPI_Graph_neighbors_count(MPI_Comm, int, int *); +int MPI_Graph_neighbors(MPI_Comm, int, int, int *); +int MPI_Cart_shift(MPI_Comm, int, int, int *, int *); +int MPI_Cart_sub(MPI_Comm, int *, MPI_Comm *); +int MPI_Cart_map(MPI_Comm, int, int *, int *, int *); +int MPI_Graph_map(MPI_Comm, int, int *, int *, int *); +int MPI_Get_processor_name(char *, int *); +int MPI_Get_version(int *, int *); +int MPI_Errhandler_create(MPI_Handler_function *, MPI_Errhandler *); +int MPI_Errhandler_set(MPI_Comm, MPI_Errhandler); +int MPI_Errhandler_get(MPI_Comm, MPI_Errhandler *); +int MPI_Errhandler_free(MPI_Errhandler *); +int MPI_Error_string(int, char *, int *); +int MPI_Error_class(int, int *); +double MPI_Wtime(void); +double MPI_Wtick(void); +#ifndef MPI_Wtime +double PMPI_Wtime(void); +double PMPI_Wtick(void); +#endif +int MPI_Init(int *, char ***); +int MPI_Finalize(void); +int MPI_Initialized(int *); +int MPI_Abort(MPI_Comm, int); + + +/* Note that we may need to define a @PCONTROL_LIST@ depending on whether + stdargs are supported */ +int MPI_Pcontrol(const int, ...); + +int MPI_DUP_FN ( MPI_Comm, int, void *, void *, void *, int * ); + + +/* MPI-2 functions */ + +/* Process Creation and Management */ +int MPI_Close_port(char *); +int MPI_Comm_accept(char *, MPI_Info, int, MPI_Comm, MPI_Comm *); +int MPI_Comm_connect(char *, MPI_Info, int, MPI_Comm, MPI_Comm *); +int MPI_Comm_disconnect(MPI_Comm *); +int MPI_Comm_get_parent(MPI_Comm *); +int MPI_Comm_join(int, MPI_Comm *); +int MPI_Comm_spawn(char *, char *[], int, MPI_Info, int, MPI_Comm, MPI_Comm *, + int []); +int MPI_Comm_spawn_multiple(int, char *[], char **[], int [], MPI_Info [], int, + MPI_Comm, MPI_Comm *, int []); +int MPI_Lookup_name(char *, MPI_Info, char *); +int MPI_Open_port(MPI_Info, char *); +int MPI_Publish_name(char *, MPI_Info, char *); +int MPI_Unpublish_name(char *, MPI_Info, char *); + +/* One-Sided Communications */ +int MPI_Accumulate(void *, int, MPI_Datatype, int, MPI_Aint, int, + MPI_Datatype, MPI_Op, MPI_Win); +int MPI_Get(void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, + MPI_Win); +int MPI_Put(void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, + MPI_Win); +int MPI_Win_complete(MPI_Win); +int MPI_Win_create(void *, MPI_Aint, int, MPI_Info, MPI_Comm, MPI_Win *); +int MPI_Win_fence(int, MPI_Win); +int MPI_Win_free(MPI_Win *); +int MPI_Win_get_group(MPI_Win, MPI_Group *); +int MPI_Win_lock(int, int, int, MPI_Win); +int MPI_Win_post(MPI_Group, int, MPI_Win); +int MPI_Win_start(MPI_Group, int, MPI_Win); +int MPI_Win_test(MPI_Win, int *); +int MPI_Win_unlock(int, MPI_Win); +int MPI_Win_wait(MPI_Win); + +/* Extended Collective Operations */ +int MPI_Alltoallw(void *, int [], int [], MPI_Datatype [], void *, int [], + int [], MPI_Datatype [], MPI_Comm); +int MPI_Exscan(void *, void *, int, MPI_Datatype, MPI_Op, MPI_Comm) ; + +/* External Interfaces */ +int MPI_Add_error_class(int *); +int MPI_Add_error_code(int, int *); +int MPI_Add_error_string(int, char *); +int MPI_Comm_call_errhandler(MPI_Comm, int); +int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *, + MPI_Comm_delete_attr_function *, int *, void *); +int MPI_Comm_delete_attr(MPI_Comm, int); +int MPI_Comm_free_keyval(int *); +int MPI_Comm_get_attr(MPI_Comm, int, void *, int *); +int MPI_Comm_get_name(MPI_Comm, char *, int *); +int MPI_Comm_set_attr(MPI_Comm, int, void *); +int MPI_Comm_set_name(MPI_Comm, char *); +int MPI_File_call_errhandler(MPI_File, int); +int MPI_Grequest_complete(MPI_Request); +int MPI_Grequest_start(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, void *, MPI_Request *); +int MPI_Init_thread(int *, char ***, int, int *); +int MPI_Is_thread_main(int *); +int MPI_Query_thread(int *); +int MPI_Status_set_cancelled(MPI_Status *, int); +int MPI_Status_set_elements(MPI_Status *, MPI_Datatype, int); +int MPI_Type_create_keyval(MPI_Type_copy_attr_function *, + MPI_Type_delete_attr_function *, int *, void *); +int MPI_Type_delete_attr(MPI_Datatype, int); +int MPI_Type_dup(MPI_Datatype, MPI_Datatype *); +int MPI_Type_free_keyval(int *); +int MPI_Type_get_attr(MPI_Datatype, int, void *, int *); +int MPI_Type_get_contents(MPI_Datatype, int, int, int, int [], MPI_Aint [], + MPI_Datatype []); +int MPI_Type_get_envelope(MPI_Datatype, int *, int *, int *, int *); +int MPI_Type_get_name(MPI_Datatype, char *, int *); +int MPI_Type_set_attr(MPI_Datatype, int, void *); +int MPI_Type_set_name(MPI_Datatype, char *); +int MPI_Type_match_size( int, int, MPI_Datatype *); +int MPI_Win_call_errhandler(MPI_Win, int); +int MPI_Win_create_keyval(MPI_Win_copy_attr_function *, + MPI_Win_delete_attr_function *, int *, void *); +int MPI_Win_delete_attr(MPI_Win, int); +int MPI_Win_free_keyval(int *); +int MPI_Win_get_attr(MPI_Win, int, void *, int *); +int MPI_Win_get_name(MPI_Win, char *, int *); +int MPI_Win_set_attr(MPI_Win, int, void *); +int MPI_Win_set_name(MPI_Win, char *); + +/* Miscellany */ +#ifdef FOO +MPI_Comm MPI_Comm_f2c(MPI_Fint); +MPI_Datatype MPI_Type_f2c(MPI_Fint); +MPI_File MPI_File_f2c(MPI_Fint); +MPI_Fint MPI_Comm_c2f(MPI_Comm); +MPI_Fint MPI_File_c2f(MPI_File); +MPI_Fint MPI_Group_c2f(MPI_Group); +MPI_Fint MPI_Info_c2f(MPI_Info); +MPI_Fint MPI_Op_c2f(MPI_Op); +MPI_Fint MPI_Request_c2f(MPI_Request); +MPI_Fint MPI_Type_c2f(MPI_Datatype); +MPI_Fint MPI_Win_c2f(MPI_Win); +MPI_Group MPI_Group_f2c(MPI_Fint); +MPI_Info MPI_Info_f2c(MPI_Fint); +MPI_Op MPI_Op_f2c(MPI_Fint); +MPI_Request MPI_Request_f2c(MPI_Fint); +MPI_Win MPI_Win_f2c(MPI_Fint); +#endif + +int MPI_Alloc_mem(MPI_Aint, MPI_Info info, void *baseptr); +int MPI_Comm_create_errhandler(MPI_Comm_errhandler_function *, MPI_Errhandler *); +int MPI_Comm_get_errhandler(MPI_Comm, MPI_Errhandler *); +int MPI_Comm_set_errhandler(MPI_Comm, MPI_Errhandler); +int MPI_File_create_errhandler(MPI_File_errhandler_function *, MPI_Errhandler *); +int MPI_File_get_errhandler(MPI_File, MPI_Errhandler *); +int MPI_File_set_errhandler(MPI_File, MPI_Errhandler); +int MPI_Finalized(int *); +int MPI_Free_mem(void *); +int MPI_Get_address(void *, MPI_Aint *); +int MPI_Info_create(MPI_Info *); +int MPI_Info_delete(MPI_Info, char *); +int MPI_Info_dup(MPI_Info, MPI_Info *); +int MPI_Info_free(MPI_Info *info); +int MPI_Info_get(MPI_Info, char *, int, char *, int *); +int MPI_Info_get_nkeys(MPI_Info, int *); +int MPI_Info_get_nthkey(MPI_Info, int, char *); +int MPI_Info_get_valuelen(MPI_Info, char *, int *, int *); +int MPI_Info_set(MPI_Info, char *, char *); +int MPI_Pack_external(char *, void *, int, MPI_Datatype, void *, MPI_Aint, + MPI_Aint *); +int MPI_Pack_external_size(char *, int, MPI_Datatype, MPI_Aint *); +int MPI_Request_get_status(MPI_Request, int *, MPI_Status *); +int MPI_Status_c2f(MPI_Status *, MPI_Fint *); +int MPI_Status_f2c(MPI_Fint *, MPI_Status *); +int MPI_Type_create_darray(int, int, int, int [], int [], int [], int [], int, + MPI_Datatype, MPI_Datatype *); +int MPI_Type_create_hindexed(int, int [], MPI_Aint [], MPI_Datatype, + MPI_Datatype *); +int MPI_Type_create_hvector(int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *); +int MPI_Type_create_indexed_block(int, int, int [], MPI_Datatype, + MPI_Datatype *); +int MPI_Type_create_resized(MPI_Datatype, MPI_Aint, MPI_Aint, MPI_Datatype *); +int MPI_Type_create_struct(int, int [], MPI_Aint [], MPI_Datatype [], + MPI_Datatype *); +int MPI_Type_create_subarray(int, int [], int [], int [], int, MPI_Datatype, + MPI_Datatype *); +int MPI_Type_get_extent(MPI_Datatype, MPI_Aint *, MPI_Aint *); +int MPI_Type_get_true_extent(MPI_Datatype, MPI_Aint *, MPI_Aint *); +int MPI_Unpack_external(char *, void *, MPI_Aint, MPI_Aint *, void *, int, + MPI_Datatype); +int MPI_Win_create_errhandler(MPI_Win_errhandler_function *, MPI_Errhandler *); +int MPI_Win_get_errhandler(MPI_Win, MPI_Errhandler *); +int MPI_Win_set_errhandler(MPI_Win, MPI_Errhandler); + +/* Fortran 90-related functions. These routines are available only if + Fortran 90 support is enabled +*/ +int MPI_Type_create_f90_integer( int, MPI_Datatype * ); +int MPI_Type_create_f90_real( int, int, MPI_Datatype * ); +int MPI_Type_create_f90_complex( int, int, MPI_Datatype * ); + +/* MPI-2.2 functions */ +int MPI_Reduce_local(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op); +int MPI_Op_commutative(MPI_Op op, int *commute); +int MPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); +int MPI_Dist_graph_create_adjacent(MPI_Comm comm_old, int indegree, int [], int [], int outdegree, int [], int [], MPI_Info info, int reorder, MPI_Comm *comm_dist_graph); +int MPI_Dist_graph_create(MPI_Comm comm_old, int n, int [], int [], int [], int [], MPI_Info info, int reorder, MPI_Comm *comm_dist_graph); +int MPI_Dist_graph_neighbors_count(MPI_Comm comm, int *indegree, int *outdegree, int *weighted); +int MPI_Dist_graph_neighbors(MPI_Comm comm, int maxindegree, int [], int [], int maxoutdegree, int [], int []); + +/* End Prototypes */ +#endif /* MPICH_SUPPRESS_PROTOTYPES */ + + + +/* Here are the bindings of the profiling routines */ +#if !defined(MPI_BUILD_PROFILING) +int PMPI_Send(void*, int, MPI_Datatype, int, int, MPI_Comm); +int PMPI_Recv(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *); +int PMPI_Get_count(MPI_Status *, MPI_Datatype, int *); +int PMPI_Bsend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int PMPI_Ssend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int PMPI_Rsend(void*, int, MPI_Datatype, int, int, MPI_Comm); +int PMPI_Buffer_attach( void* buffer, int); +int PMPI_Buffer_detach( void* buffer, int *); +int PMPI_Isend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Ibsend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Issend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Irsend(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Irecv(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Wait(MPI_Request *, MPI_Status *); +int PMPI_Test(MPI_Request *, int *, MPI_Status *); +int PMPI_Request_free(MPI_Request *); +int PMPI_Waitany(int, MPI_Request *, int *, MPI_Status *); +int PMPI_Testany(int, MPI_Request *, int *, int *, MPI_Status *); +int PMPI_Waitall(int, MPI_Request *, MPI_Status *); +int PMPI_Testall(int, MPI_Request *, int *, MPI_Status *); +int PMPI_Waitsome(int, MPI_Request *, int *, int *, MPI_Status *); +int PMPI_Testsome(int, MPI_Request *, int *, int *, MPI_Status *); +int PMPI_Iprobe(int, int, MPI_Comm, int *, MPI_Status *); +int PMPI_Probe(int, int, MPI_Comm, MPI_Status *); +int PMPI_Cancel(MPI_Request *); +int PMPI_Test_cancelled(MPI_Status *, int *); +int PMPI_Send_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Bsend_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Ssend_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Rsend_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Recv_init(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *); +int PMPI_Start(MPI_Request *); +int PMPI_Startall(int, MPI_Request *); +int PMPI_Sendrecv(void *, int, MPI_Datatype, int, int, void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *); +int PMPI_Sendrecv_replace(void*, int, MPI_Datatype, int, int, int, int, MPI_Comm, MPI_Status *); +int PMPI_Type_contiguous(int, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_vector(int, int, int, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_hvector(int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_indexed(int, int *, int *, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_hindexed(int, int *, MPI_Aint *, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_struct(int, int *, MPI_Aint *, MPI_Datatype *, MPI_Datatype *); +int PMPI_Address(void*, MPI_Aint *); +int PMPI_Type_extent(MPI_Datatype, MPI_Aint *); +int PMPI_Type_size(MPI_Datatype, int *); +int PMPI_Type_lb(MPI_Datatype, MPI_Aint *); +int PMPI_Type_ub(MPI_Datatype, MPI_Aint *); +int PMPI_Type_commit(MPI_Datatype *); +int PMPI_Type_free(MPI_Datatype *); +int PMPI_Get_elements(MPI_Status *, MPI_Datatype, int *); +int PMPI_Pack(void*, int, MPI_Datatype, void *, int, int *, MPI_Comm); +int PMPI_Unpack(void*, int, int *, void *, int, MPI_Datatype, MPI_Comm); +int PMPI_Pack_size(int, MPI_Datatype, MPI_Comm, int *); +int PMPI_Barrier(MPI_Comm ); +int PMPI_Bcast(void* buffer, int, MPI_Datatype, int, MPI_Comm ); +int PMPI_Gather(void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int PMPI_Gatherv(void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, int, MPI_Comm); +int PMPI_Scatter(void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int PMPI_Scatterv(void* , int *, int *displs, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm); +int PMPI_Allgather(void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm); +int PMPI_Allgatherv(void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm); +int PMPI_Alltoall(void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm); +int PMPI_Alltoallv(void* , int *, int *, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm); +int PMPI_Reduce(void* , void*, int, MPI_Datatype, MPI_Op, int, MPI_Comm); +int PMPI_Op_create(MPI_User_function *, int, MPI_Op *); +int PMPI_Op_free( MPI_Op *); +int PMPI_Allreduce(void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm); +int PMPI_Reduce_scatter(void* , void*, int *, MPI_Datatype, MPI_Op, MPI_Comm); +int PMPI_Scan(void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm ); +int PMPI_Group_size(MPI_Group, int *); +int PMPI_Group_rank(MPI_Group, int *); +int PMPI_Group_translate_ranks (MPI_Group, int, int *, MPI_Group, int *); +int PMPI_Group_compare(MPI_Group, MPI_Group, int *); +int PMPI_Comm_group(MPI_Comm, MPI_Group *); +int PMPI_Group_union(MPI_Group, MPI_Group, MPI_Group *); +int PMPI_Group_intersection(MPI_Group, MPI_Group, MPI_Group *); +int PMPI_Group_difference(MPI_Group, MPI_Group, MPI_Group *); +int PMPI_Group_incl(MPI_Group, int, int *, MPI_Group *); +int PMPI_Group_excl(MPI_Group, int, int *, MPI_Group *); +int PMPI_Group_range_incl(MPI_Group, int, int [][3], MPI_Group *); +int PMPI_Group_range_excl(MPI_Group, int, int [][3], MPI_Group *); +int PMPI_Group_free(MPI_Group *); +int PMPI_Comm_size(MPI_Comm, int *); +int PMPI_Comm_rank(MPI_Comm, int *); +int PMPI_Comm_compare(MPI_Comm, MPI_Comm, int *); +int PMPI_Comm_dup(MPI_Comm, MPI_Comm *); +int PMPI_Comm_create(MPI_Comm, MPI_Group, MPI_Comm *); +int PMPI_Comm_split(MPI_Comm, int, int, MPI_Comm *); +int PMPI_Comm_free(MPI_Comm *); +int PMPI_Comm_test_inter(MPI_Comm, int *); +int PMPI_Comm_remote_size(MPI_Comm, int *); +int PMPI_Comm_remote_group(MPI_Comm, MPI_Group *); +int PMPI_Intercomm_create(MPI_Comm, int, MPI_Comm, int, int, MPI_Comm *); +int PMPI_Intercomm_merge(MPI_Comm, int, MPI_Comm *); +int PMPI_Keyval_create(MPI_Copy_function *, MPI_Delete_function *, int *, void*); +int PMPI_Keyval_free(int *); +int PMPI_Attr_put(MPI_Comm, int, void*); +int PMPI_Attr_get(MPI_Comm, int, void *, int *); +int PMPI_Attr_delete(MPI_Comm, int); +int PMPI_Topo_test(MPI_Comm, int *); +int PMPI_Cart_create(MPI_Comm, int, int *, int *, int, MPI_Comm *); +int PMPI_Dims_create(int, int, int *); +int PMPI_Graph_create(MPI_Comm, int, int *, int *, int, MPI_Comm *); +int PMPI_Graphdims_get(MPI_Comm, int *, int *); +int PMPI_Graph_get(MPI_Comm, int, int, int *, int *); +int PMPI_Cartdim_get(MPI_Comm, int *); +int PMPI_Cart_get(MPI_Comm, int, int *, int *, int *); +int PMPI_Cart_rank(MPI_Comm, int *, int *); +int PMPI_Cart_coords(MPI_Comm, int, int, int *); +int PMPI_Graph_neighbors_count(MPI_Comm, int, int *); +int PMPI_Graph_neighbors(MPI_Comm, int, int, int *); +int PMPI_Cart_shift(MPI_Comm, int, int, int *, int *); +int PMPI_Cart_sub(MPI_Comm, int *, MPI_Comm *); +int PMPI_Cart_map(MPI_Comm, int, int *, int *, int *); +int PMPI_Graph_map(MPI_Comm, int, int *, int *, int *); +int PMPI_Get_processor_name(char *, int *); +int PMPI_Get_version(int *, int *); +int PMPI_Errhandler_create(MPI_Handler_function *, MPI_Errhandler *); +int PMPI_Errhandler_set(MPI_Comm, MPI_Errhandler); +int PMPI_Errhandler_get(MPI_Comm, MPI_Errhandler *); +int PMPI_Errhandler_free(MPI_Errhandler *); +int PMPI_Error_string(int, char *, int *); +int PMPI_Error_class(int, int *); + +/* Wtime done above */ +int PMPI_Init(int *, char ***); +int PMPI_Finalize(void); +int PMPI_Initialized(int *); +int PMPI_Abort(MPI_Comm, int); + +int PMPI_Pcontrol(const int, ...); + +/* MPI-2 functions */ + +/* Process Creation and Management */ +int PMPI_Close_port(char *); +int PMPI_Comm_accept(char *, MPI_Info, int, MPI_Comm, MPI_Comm *); +int PMPI_Comm_connect(char *, MPI_Info, int, MPI_Comm, MPI_Comm *); +int PMPI_Comm_disconnect(MPI_Comm *); +int PMPI_Comm_get_parent(MPI_Comm *); +int PMPI_Comm_join(int, MPI_Comm *); +int PMPI_Comm_spawn(char *, char *[], int, MPI_Info, int, MPI_Comm, MPI_Comm *, + int []); +int PMPI_Comm_spawn_multiple(int, char *[], char **[], int [], MPI_Info [], int, + MPI_Comm, MPI_Comm *, int []); +int PMPI_Lookup_name(char *, MPI_Info, char *); +int PMPI_Open_port(MPI_Info, char *); +int PMPI_Publish_name(char *, MPI_Info, char *); +int PMPI_Unpublish_name(char *, MPI_Info, char *); + +/* One-Sided Communications */ +int PMPI_Accumulate(void *, int, MPI_Datatype, int, MPI_Aint, int, + MPI_Datatype, MPI_Op, MPI_Win); +int PMPI_Get(void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, + MPI_Win); +int PMPI_Put(void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, + MPI_Win); +int PMPI_Win_complete(MPI_Win); +int PMPI_Win_create(void *, MPI_Aint, int, MPI_Info, MPI_Comm, MPI_Win *); +int PMPI_Win_fence(int, MPI_Win); +int PMPI_Win_free(MPI_Win *); +int PMPI_Win_get_group(MPI_Win, MPI_Group *); +int PMPI_Win_lock(int, int, int, MPI_Win); +int PMPI_Win_post(MPI_Group, int, MPI_Win); +int PMPI_Win_start(MPI_Group, int, MPI_Win); +int PMPI_Win_test(MPI_Win, int *); +int PMPI_Win_unlock(int, MPI_Win); +int PMPI_Win_wait(MPI_Win); + +/* Extended Collective Operations */ +int PMPI_Alltoallw(void *, int [], int [], MPI_Datatype [], void *, int [], + int [], MPI_Datatype [], MPI_Comm); +int PMPI_Exscan(void *, void *, int, MPI_Datatype, MPI_Op, MPI_Comm) ; + +/* External Interfaces */ +int PMPI_Add_error_class(int *); +int PMPI_Add_error_code(int, int *); +int PMPI_Add_error_string(int, char *); +int PMPI_Comm_call_errhandler(MPI_Comm, int); +int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function *, + MPI_Comm_delete_attr_function *, int *, void *); +int PMPI_Comm_delete_attr(MPI_Comm, int); +int PMPI_Comm_free_keyval(int *); +int PMPI_Comm_get_attr(MPI_Comm, int, void *, int *); +int PMPI_Comm_get_name(MPI_Comm, char *, int *); +int PMPI_Comm_set_attr(MPI_Comm, int, void *); +int PMPI_Comm_set_name(MPI_Comm, char *); +int PMPI_File_call_errhandler(MPI_File, int); +int PMPI_Grequest_complete(MPI_Request); +int PMPI_Grequest_start(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, void *, MPI_Request *); +int PMPI_Init_thread(int *, char ***, int, int *); +int PMPI_Is_thread_main(int *); +int PMPI_Query_thread(int *); +int PMPI_Status_set_cancelled(MPI_Status *, int); +int PMPI_Status_set_elements(MPI_Status *, MPI_Datatype, int); +int PMPI_Type_create_keyval(MPI_Type_copy_attr_function *, + MPI_Type_delete_attr_function *, int *, void *); +int PMPI_Type_delete_attr(MPI_Datatype, int); +int PMPI_Type_dup(MPI_Datatype, MPI_Datatype *); +int PMPI_Type_free_keyval(int *); +int PMPI_Type_get_attr(MPI_Datatype, int, void *, int *); +int PMPI_Type_get_contents(MPI_Datatype, int, int, int, int [], MPI_Aint [], + MPI_Datatype []); +int PMPI_Type_get_envelope(MPI_Datatype, int *, int *, int *, int *); +int PMPI_Type_get_name(MPI_Datatype, char *, int *); +int PMPI_Type_set_attr(MPI_Datatype, int, void *); +int PMPI_Type_set_name(MPI_Datatype, char *); +int PMPI_Type_match_size( int, int, MPI_Datatype *); +int PMPI_Win_call_errhandler(MPI_Win, int); +int PMPI_Win_create_keyval(MPI_Win_copy_attr_function *, + MPI_Win_delete_attr_function *, int *, void *); +int PMPI_Win_delete_attr(MPI_Win, int); +int PMPI_Win_free_keyval(int *); +int PMPI_Win_get_attr(MPI_Win, int, void *, int *); +int PMPI_Win_get_name(MPI_Win, char *, int *); +int PMPI_Win_set_attr(MPI_Win, int, void *); +int PMPI_Win_set_name(MPI_Win, char *); + +/* Fortran 90-related functions. These routines are available only if + Fortran 90 support is enabled +*/ +int PMPI_Type_create_f90_integer( int, MPI_Datatype * ); +int PMPI_Type_create_f90_real( int, int, MPI_Datatype * ); +int PMPI_Type_create_f90_complex( int, int, MPI_Datatype * ); + +/* Miscellany */ +int PMPI_Alloc_mem(MPI_Aint, MPI_Info info, void *baseptr); +int PMPI_Comm_create_errhandler(MPI_Comm_errhandler_function *, MPI_Errhandler *); +int PMPI_Comm_get_errhandler(MPI_Comm, MPI_Errhandler *); +int PMPI_Comm_set_errhandler(MPI_Comm, MPI_Errhandler); +int PMPI_File_create_errhandler(MPI_File_errhandler_function *, MPI_Errhandler *); +int PMPI_File_get_errhandler(MPI_File, MPI_Errhandler *); +int PMPI_File_set_errhandler(MPI_File, MPI_Errhandler); +int PMPI_Finalized(int *); +int PMPI_Free_mem(void *); +int PMPI_Get_address(void *, MPI_Aint *); +int PMPI_Info_create(MPI_Info *); +int PMPI_Info_delete(MPI_Info, char *); +int PMPI_Info_dup(MPI_Info, MPI_Info *); +int PMPI_Info_free(MPI_Info *info); +int PMPI_Info_get(MPI_Info, char *, int, char *, int *); +int PMPI_Info_get_nkeys(MPI_Info, int *); +int PMPI_Info_get_nthkey(MPI_Info, int, char *); +int PMPI_Info_get_valuelen(MPI_Info, char *, int *, int *); +int PMPI_Info_set(MPI_Info, char *, char *); +int PMPI_Pack_external(char *, void *, int, MPI_Datatype, void *, MPI_Aint, + MPI_Aint *); +int PMPI_Pack_external_size(char *, int, MPI_Datatype, MPI_Aint *); +int PMPI_Request_get_status(MPI_Request, int *, MPI_Status *); +int PMPI_Status_c2f(MPI_Status *, MPI_Fint *); +int PMPI_Status_f2c(MPI_Fint *, MPI_Status *); +int PMPI_Type_create_darray(int, int, int, int [], int [], int [], int [], int, + MPI_Datatype, MPI_Datatype *); +int PMPI_Type_create_hindexed(int, int [], MPI_Aint [], MPI_Datatype, + MPI_Datatype *); +int PMPI_Type_create_hvector(int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *); +int PMPI_Type_create_indexed_block(int, int, int [], MPI_Datatype, + MPI_Datatype *); +int PMPI_Type_create_resized(MPI_Datatype, MPI_Aint, MPI_Aint, MPI_Datatype *); +int PMPI_Type_create_struct(int, int [], MPI_Aint [], MPI_Datatype [], + MPI_Datatype *); +int PMPI_Type_create_subarray(int, int [], int [], int [], int, MPI_Datatype, + MPI_Datatype *); +int PMPI_Type_get_extent(MPI_Datatype, MPI_Aint *, MPI_Aint *); +int PMPI_Type_get_true_extent(MPI_Datatype, MPI_Aint *, MPI_Aint *); +int PMPI_Unpack_external(char *, void *, MPI_Aint, MPI_Aint *, void *, int, + MPI_Datatype); +int PMPI_Win_create_errhandler(MPI_Win_errhandler_function *, MPI_Errhandler *); +int PMPI_Win_get_errhandler(MPI_Win, MPI_Errhandler *); +int PMPI_Win_set_errhandler(MPI_Win, MPI_Errhandler); +int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op); +int PMPI_Op_commutative(MPI_Op op, int *commute); +int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); +int PMPI_Dist_graph_create_adjacent(MPI_Comm comm_old, int indegree, int [], int [], int outdegree, int [], int [], MPI_Info info, int reorder, MPI_Comm *comm_dist_graph); +int PMPI_Dist_graph_create(MPI_Comm comm_old, int n, int [], int [], int [], int [], MPI_Info info, int reorder, MPI_Comm *comm_dist_graph); +int PMPI_Dist_graph_neighbors_count(MPI_Comm comm, int *indegree, int *outdegree, int *weighted); +int PMPI_Dist_graph_neighbors(MPI_Comm comm, int maxindegree, int [], int [], int maxoutdegree, int [], int []); +#endif /* MPI_BUILD_PROFILING */ +/* End of MPI bindings */ + +/* feature advertisement */ +#define MPIIMPL_ADVERTISES_FEATURES 1 +#define MPIIMPL_HAVE_MPI_INFO 1 +#define MPIIMPL_HAVE_MPI_COMBINER_DARRAY 1 +#define MPIIMPL_HAVE_MPI_TYPE_CREATE_DARRAY 1 +#define MPIIMPL_HAVE_MPI_COMBINER_SUBARRAY 1 +#define MPIIMPL_HAVE_MPI_TYPE_CREATE_DARRAY 1 +#define MPIIMPL_HAVE_MPI_COMBINER_DUP 1 +#define MPIIMPL_HAVE_MPI_GREQUEST 1 +#define MPIIMPL_HAVE_STATUS_SET_BYTES 1 +#define MPIIMPL_HAVE_STATUS_SET_INFO 1 + +#include "mpio.h" + +#if defined(__cplusplus) +} +/* Add the C++ bindings */ +/* + If MPICH_SKIP_MPICXX is defined, the mpicxx.h file will *not* be included. + This is necessary, for example, when building the C++ interfaces. It + can also be used when you want to use a C++ compiler to compile C code, + and do not want to load the C++ bindings. These definitions can + be made by the C++ compilation script + */ +#if !defined(MPICH_SKIP_MPICXX) +/* mpicxx.h contains the MPI C++ binding. In the mpi.h.in file, this + include is in an autoconf variable in case the compiler is a C++ + compiler but MPI was built without the C++ bindings */ +#include "mpicxx.h" +#endif +#endif + +/* BEGIN: non-standard but public extensions to MPI */ + +/* Generalized requests extensions as proposed in "Extending the MPI-2 + * Generalized Request Interface" */ +typedef int (MPIX_Grequest_poll_function)(void *, MPI_Status *); +typedef int (MPIX_Grequest_wait_function)(int, void **, double, MPI_Status *); + +typedef int MPIX_Grequest_class; +int MPIX_Grequest_class_create(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, + MPIX_Grequest_poll_function *, + MPIX_Grequest_wait_function *, + MPIX_Grequest_class *); + +int MPIX_Grequest_class_allocate(MPIX_Grequest_class, + void *, + MPI_Request *); + +int MPIX_Grequest_start(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, + MPIX_Grequest_poll_function *, + MPIX_Grequest_wait_function *, void *, MPI_Request *); +#if !defined(MPI_BUILD_PROFILING) +int PMPIX_Grequest_class_create(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, + MPIX_Grequest_poll_function *, + MPIX_Grequest_wait_function *, + MPIX_Grequest_class *); + +int PMPIX_Grequest_class_allocate(MPIX_Grequest_class, + void *, + MPI_Request *); +int PMPIX_Grequest_start(MPI_Grequest_query_function *, + MPI_Grequest_free_function *, + MPI_Grequest_cancel_function *, + MPIX_Grequest_poll_function *, + MPIX_Grequest_wait_function *, void *, MPI_Request *); +#endif +/* END: non-standard but public extensions to MPI */ + +#endif diff --git a/tools/mingw-cross/mpich2-win64/include/mpi.mod b/tools/mingw-cross/mpich2-win64/include/mpi.mod new file mode 100644 index 0000000000000000000000000000000000000000..c16cdb722a4d13187746f75e7f7db4d9c2756cf6 GIT binary patch literal 3702 zcmd5;TWb?R6h2LCt=79$5JW1a_#lQf_bQ4>x~-8mDcMv(0zs?QD5k|e=~L*x5ET3w zKKSmF&ps93{RyJzH)r-VGvju%r3fzU&SmF2-#6!+xs1~YO&ldUPed^Q_((#W=NaH7!YHz(-Yd`At9(Q|B+v{`b_RGy~3MDPC)Jzdm zX2Yl_P#+)Rj$~j}w~R4iRmQ0g(f)Bs2dC|DC($7;0}+!b6I@r_`d4ynG8igKbwANG zCcRKyuFTG$((zm6)~esBE!G=Nk4AwJ9MM#t=#;V&nCPog%<)+8o>dt2h<)9{z#t7a zQ4vrAqf}ckNwmZI#D-hO^?^>Y;XcS1KJa$EpoGWuf}Z5wUPu^Tki>UqEN$^pm{-Ea zxZaU=TrZ6?AUP(H6Mkt+rexVml}4-8Sf(QYoe?IYepHI6u_{Hlz$fqpLT)^oE#S6O zS+BL>0&^^|R`0AVm8%|2zWU&X?gQ>9I&_|)!2iG zJi+*ZNb$cL=pu_OHy7{uo%-t15}gE4vYPKaOGN6=8YDvl6 z>W`Mjn}VovQ{8Qw%R}sijS&vFjH{iuK4{k)@nGi@&Jjbq^ob6^m|D#~SCh2G2i%TW z8K-%`@Q9XnBdP(z#s=%01CbPK`B}oG@@VK2hhgsM>FY)D`dp-Ya-j z3a|I3*L!pcwa<7_l;_!jw?sK<;ne1^OLIHC6e+KDTZ{wgsl$!o;2fv?p!G1_^D3ZUD6d z^e3A(^zvcbVB)vfI37k3XKj!WXDI{J51?<`#O8T!Lz(Y7GG;A`FK2^$4B;*3@TM{&Q4 XToDBuBmxV(A~t|_xI#BS+Xnps>8)$0 literal 0 HcmV?d00001 diff --git a/tools/mingw-cross/mpich2-win64/include/mpi_base.mod b/tools/mingw-cross/mpich2-win64/include/mpi_base.mod new file mode 100644 index 0000000000000000000000000000000000000000..93b8e55b2240807f38f528745af8f3b8045f5e07 GIT binary patch literal 90551 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

Kz0a{x4A`q&Jg732INdZu7I&Cs%VxV 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%0ARz@)rSA`@j@r|Qr@;7v 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 BWrqL& literal 0 HcmV?d00001 diff --git a/tools/mingw-cross/mpich2-win64/include/mpi_constants.mod b/tools/mingw-cross/mpich2-win64/include/mpi_constants.mod new file mode 100644 index 0000000000000000000000000000000000000000..57748f38cbbc11e3b00aa6c9a050e955856aa807 GIT binary patch literal 36141 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 E0Y%kY$N&HU literal 0 HcmV?d00001 diff --git a/tools/mingw-cross/mpich2-win64/include/mpi_sizeofs.mod b/tools/mingw-cross/mpich2-win64/include/mpi_sizeofs.mod new file mode 100644 index 0000000000000000000000000000000000000000..bb1eb0779214a0477f4d3e416a4fac606b63bb11 GIT binary patch literal 8417 zcmcJUKWrRD6vpSAb8H8b00t5a!RI&*|IOVQ!x<7V_#AxXAkjs-oRE9$tWkdsWUn!D01O?zNvP_1O{PDRy9O|v)MRyO-?YigQ%(rp!U?`=&@L$p)) zbK8PD7As|x0QMuDP&1IXs_cR5wt9;_ z7?U4MDqH4NGx9iIFL~4^^I{>8O8~-ya5)G#WjhcKz?PHAg1{aqiZ#Sd=4CELba3MHV?5`yEp~DoUrsJIk6LA3EEHZ!15hU5a!?AiJd{b;QdCxD zum_6bEs&ec%c_imjo$gSh1z<7z}s&C!XdaE1QJak9ER5(|>^lX&{Pc&a)SwTp9;} z&cNk>K1<63Ey9kiO!gpw@-*N!iuHZ3Kx08tvjh^G$N9;;*vjM+MF1q94;{!dEe~=Q zwiK0h=XFn*`7s_XZZa?H&dc%SWMcEEP3FZy;L0EX;W@Y*ggIIs!t=0WtBE~Ol-=Pc zsir-+zxKPDs96Gu1x!WL{P^ zaXdMh*gR^Jd9e`qq#JD9Y~elU(cvQCI!0CTf;IVnK3# zGA|Y+Ur+=<9)rt)e3_O9`3h_)Dyy2<14Sh-y<}ciHE}#SnbDtp7T|Ia zUZv$ByaqeAn%DzH*&Ticys;baqxxM<)GUF-g5>;UUMxty#|nU4gv)`f(()jeU`tV1 z)x;hsD!I7JysT>CcycnadDJHJVj=LwT>!#yxEzGnX?Y0Cuw$!$h zt?|N{x!=Lb+t6A3b@Nth(=BrdP5*`5_T4BSgJ*XII`D^y3N9i>QP8joe$YE;cm;Uo z(gZf9I|?eH2%%sDF^Yn^Rq&(ULES4D#BE(cRPQP{7K-o+Sf-Z|qbR@&`~ti`!^;Dn zIt+`;(7-cj95(|+1N;`lG(sA|5TW8T1ZgT-R>jRg7cH-1Vn|of>Z&*s3=t}>AxKey z&lCkr};%oR774Uad z{1FThDkkv=qNu>f7^=7eucD%!sQ4FtMFspF6=gg~=^Ka+5O5BI0o zrw$3+I3|bTIDrQhWe^5fAx98%H5?<9Tt}3q1Yez~%kDg;~xa6DjbhfSUzby TDhZDp2vBtj9{K&j7_a1i>K?s9 literal 0 HcmV?d00001 diff --git a/tools/mingw-cross/mpich2-win64/include/mpicxx.h b/tools/mingw-cross/mpich2-win64/include/mpicxx.h new file mode 100644 index 0000000000..5891ddc8d7 --- /dev/null +++ b/tools/mingw-cross/mpich2-win64/include/mpicxx.h @@ -0,0 +1,2716 @@ +/* -*- Mode: C++; c-basic-offset:4 ; -*- */ +/* + * (C) 2001 by Argonne National Laboratory. + * See COPYRIGHT in top-level directory. + * + * This file is automatically generated by buildiface -nosep + * DO NOT EDIT + */ +/* style: c++ header */ + +#ifdef MPI +#error "You cannot define MPI; that name is reserved for the MPI namespace" +#endif + +// Check for incompatible GCC versions +// GCC (specifically) g++ changed the calling convention +// between 3.2.3 and 3.4.3 (!!) Normally such changes +// should only occur at major releases (e.g., version 3 to 4) +#ifdef __GNUC__ +# if __GNUC__ >= 0 +# if __GNUC_MINOR__ > 2 && 0 == 2 +# error 'Please use the same version of GCC and g++ for compiling MPICH2 and user MPI programs' +# endif +# endif +#endif + +/* + * Because the API is defined, some methods have parameters that are + * not used. The following definition allows us to suppress warnings + * about unused arguments in methods when -Wall -Wextra are specified. + * this definition is removed at the end of this file. + */ +#ifdef MPIR_ARGUNUSED +#error MPIR_ARGUNUSED defined +#endif +#if defined(__GNUC__) && __GNUC__ >= 4 +#define MPIR_ARGUNUSED __attribute__((unused)) +#else +#define MPIR_ARGUNUSED +#endif +// There is a name conflict between stdio.h and iostream (or iostream.h) +// and the MPI C++ binding with respect to the names SEEK_SET, SEEK_CUR, +// and SEEK_END. MPI wants these in the MPI namespace, but stdio.h, +// iostream, or iostream.h will #define these to integer values. +// #undef'ing these can cause obscure problems. +#ifndef MPICH_IGNORE_CXX_SEEK + +// MPICH_DONT_INCLUDE_STDIO_H is another escape hatch for us, just like +// MPICH_IGNORE_CXX_SEEK. If we encounter a wacky environment or user in the +// wild that does not want our workaround and/or the stdio.h header, then we can +// offer them a way out. +#ifndef MPICH_DONT_INCLUDE_STDIO_H +// ensure that we have SEEK_* defined +# include +#endif + +enum MPIR_Dummy_seek_type { + MPIR_DUMMY_SEEK_COMMA_VAL = -1 // permits cleaner comma logic +#ifdef SEEK_SET + , MPIR_SEEK_SET = SEEK_SET +# undef SEEK_SET + , SEEK_SET = MPIR_SEEK_SET +#endif +#ifdef SEEK_CUR + , MPIR_SEEK_CUR = SEEK_CUR +# undef SEEK_CUR + , SEEK_CUR = MPIR_SEEK_CUR +#endif +#ifdef SEEK_END + , MPIR_SEEK_END = SEEK_END +# undef SEEK_END + , SEEK_END = MPIR_SEEK_END +#endif +#ifdef LOCK_SHARED + , MPIR_LOCK_SHARED = LOCK_SHARED +# undef LOCK_SHARED + , LOCK_SHARED = MPIR_LOCK_SHARED +#endif +}; + +#endif // MPICH_IGNORE_CXX_SEEK +namespace MPI { +#if 1 +#define MPIX_CALLREF( _objptr, fnc ) \ + { int err = fnc; if (err) { (_objptr)->Call_errhandler( err ); }} +#define MPIX_CALLOBJ( _obj, fnc ) \ + { int err = fnc; if (err) { (_obj).Call_errhandler( err ); }} +#define MPIX_CALLWORLD( fnc ) \ + { int err = fnc ; if (err) MPIR_Call_world_errhand( err ); } +extern void MPIR_Call_world_errhand( int ); +#else +#define MPIX_CALLREF( _objptr, fnc ) (void)fnc +#define MPIX_CALLOBJ( _obj, fnc ) (void)fnc +#define MPIX_CALLWORLD( fnc ) (void)fnc +#endif + +// Typedefs for basic int types +typedef MPI_Offset Offset; +typedef MPI_Aint Aint; +typedef MPI_Fint Fint; + +// Special internal routine +void MPIR_CXX_InitDatatypeNames( void ); + +// Forward class declarations +class Comm; +class Nullcomm; +class Intercomm; +class Intracomm; +class Cartcomm; +class Graphcomm; +class File; + +// base (classless) routines +extern int Detach_buffer( void *&v1 ) ; +extern bool Is_initialized( void ) ; +extern void Get_processor_name( char * v1, int &v2 ) ; +extern void Get_error_string( int v1, char * v2, int &v3 ) ; +extern void Compute_dims( int v1, int v2, int * v3 ) ; +extern void Get_version( int &v1, int &v2 ) ; +extern void Finalize( void ) ; +extern void Pcontrol( const int v1, ... ) ; +extern void Attach_buffer( void* v1, int v2 ) ; +extern int Get_error_class( int v1 ) ; +extern Intracomm COMM_WORLD; +extern File FILE_NULL; + +class Exception { + + protected: + int the_real_exception; + + public: + // new/delete + + inline Exception(int obj) : the_real_exception(obj) {} + inline Exception(void) : the_real_exception(0) {} + + virtual ~Exception() {} + // copy/assignment + + Exception(const Exception &obj) : the_real_exception(obj.the_real_exception){} + + Exception& operator=(const Exception &obj) { + the_real_exception = obj.the_real_exception; return *this; } + + // logical + bool operator== (const Exception &obj) { + return (the_real_exception == obj.the_real_exception); } + bool operator!= (const Exception &obj) { + return (the_real_exception != obj.the_real_exception); } + // C/C++ cast and assignment + inline operator int*() { return &the_real_exception; } + inline operator int() const { return the_real_exception; } + Exception& operator=(const int& obj) { + the_real_exception = obj; return *this; } + + protected: + char the_error_message[MPI_MAX_ERROR_STRING]; + public: + int Get_error_code(void) { return the_real_exception; } + int Get_error_class(void) { return MPI::Get_error_class(the_real_exception); } + const char *Get_error_string(void) + { + int len; + MPI_Error_string(the_real_exception, the_error_message, &len); + return the_error_message; + } +}; + +class Datatype { + friend class Comm; + friend class Status; + friend class Intracomm; + friend class Intercomm; + friend class Win; + friend class File; + friend class Op; + + protected: + MPI_Datatype the_real_datatype; + + public: + // new/delete + + inline Datatype(MPI_Datatype obj) : the_real_datatype(obj) {} + inline Datatype(void) : the_real_datatype(MPI_DATATYPE_NULL) {} + + virtual ~Datatype() {} + // copy/assignment + + Datatype(const Datatype &obj) : the_real_datatype(obj.the_real_datatype){} + + Datatype& operator=(const Datatype &obj) { + the_real_datatype = obj.the_real_datatype; return *this; } + + // logical + bool operator== (const Datatype &obj) { + return (the_real_datatype == obj.the_real_datatype); } + bool operator!= (const Datatype &obj) { + return (the_real_datatype != obj.the_real_datatype); } + // C/C++ cast and assignment + inline operator MPI_Datatype*() { return &the_real_datatype; } + inline operator MPI_Datatype() const { return the_real_datatype; } + Datatype& operator=(const MPI_Datatype& obj) { + the_real_datatype = obj; return *this; } + virtual void Commit( void ) + { + MPIX_CALLWORLD( MPI_Type_commit( (MPI_Datatype *) &the_real_datatype )); + } + virtual void Free( void ) + { + MPIX_CALLWORLD( MPI_Type_free( (MPI_Datatype *) &the_real_datatype )); + } + virtual Datatype Create_indexed( int v1, const int * v2, const int * v3 ) const + { + Datatype v5; + MPIX_CALLWORLD( MPI_Type_indexed( v1, (int *)v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) )); + return v5; + } + virtual Datatype Create_contiguous( int v1 ) const + { + Datatype v3; + MPIX_CALLWORLD( MPI_Type_contiguous( v1, (MPI_Datatype) the_real_datatype, &(v3.the_real_datatype) )); + return v3; + } + virtual Datatype Create_vector( int v1, int v2, int v3 ) const + { + Datatype v5; + MPIX_CALLWORLD( MPI_Type_vector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) )); + return v5; + } + static Datatype Create_struct( int v1, int v2[], MPI_Aint v3[], const Datatype v4[] ) + { + Datatype v5; + MPI_Datatype *l4 = new MPI_Datatype[v1]; + { + int i4; + for (i4=0;i4BE%%*!2%)6CV}uuZ%_A~ozC`j58XYR z-GDJ5#(+^GA|eVRB1S+&LUc3_if*~eSRMP;6>l(=XY-3 zhehx@bgB@u9~9#F=|VjFtwP-J8YRy?Bm~OyAFSl2PYHqYg4>kba;*?3FIrIYVj%>| zOFpCIXWt|Q%FD+}Ua=?y%BxyRUj0!aP=4iYN^ZMJ2$a`fqvVbALZH0q4kf>JyAUXE zeU*~8-y#IcJD;rN_s;qCI5AX5GY^! zijr@_F-Q3y*gnXX)=w(gx+J!s+~rY9zGGHwLAm>fl-%pZVhhT54wRgJP;5bYz@m}| z-(PG&dFa=bJp7Ad3(A=vRr1~M6kAZvezlVCd$HJpvi*5VcJ{;;l-;m>lzn$m@&mAa zl=Gl2$^{3NTy!6?1?7@El*T>P>wuM$?7M>7L+w8N0}T{a`eGs3(B#NDS7rg#1@nrZdUT# zC9wtN`HxldV-FQuP+sskCAYjzY(aU^SjmeYDYl@z29cCC`v&xZ&UK|=Zh^UpM-iSfBQ`( zpZSE?g7S~B|0s97P|0VXAhw`<{xl_D0FF?;^lBwvf#ZPkwR4nwpd#0j=a_)sn9(}54q5R-Sm0WnEXrWwu zzLHD7C0ZztyIsj;H;Wd^fyXJi;%w1EdGh_0JQdc3^7PLsxdz&X(s`ef-fg0Va`-t) zuDwRIP*yKevIcEM8UKTl^*4wX$}!j{lxJV5N zF(+CmfBA7GAAOT(q5REDlzak~MfqFU7RqN9l>Eb&MGNJh;k=>zEAWW&Z^x8;0ggG! zm*$oH=chyq<*RV4QN987P`>pD^bu964MiW!uL+@WOt&0+@S5!Wj@>xp6p<$D&CoHHk8P_}(q$&TB_49eoo zO7})ZE za{cF&{LtIP49bnqSMnnliW!ufPFHgCzls@@AAgIIpIj3&C_iXVhc?xA7^6**DR~31pA8ezSk-F)3KOA`QU<*4}Dq8p#0_SN%92=B>xJk)BFN+zJe}(m-{M%iW{QLXF49XW@sN_Eni5Zly0)Hsqm{;=O z&_M~aK*?!miCL7>KcnOUZxFL65588( z!xqIX%EP~+KE_btO-FhnPjV61I=>l%q|jdr^J@_8;ZegGzq-fnpZrXP^$s%U-SI=dTvCD6gDX@~V%DS(IOX zqmtLcI#7OXyOP&`T+E`p@#RW>6P87JOH0XH-!EoS-hQK!cODY6D8GM>l6TLFS(NwO zq2!O>DP~dLf3uQ5yGYEUd}vO|huzpk9Ul|3D4%_vlF!4sQT_w=7v)RuQSz0SiCL7dEh+gX>@Uiq`~8!W2fj&cMR~~6l*~U+Y(+Wa%SyiM z{bDQ1BVVcHd#@2&QMS!1+5Ty<6=mn^l)ZF}Zc}p6n%IhR z>0^~VZeDCfxlAaz{C#38%E4QeTy?eBigGoq7v*W+Qu53Xi>)Y!-k_v=z1WJfd`L-u zx7dnuf47-<9R+KNmF+lm!ZA!lK9I+MUYnLeb=DgU7@~zKHnFFq+%syYtp`5a!KIKl#6du^4J^19LnRbR`SFHVh-g= zi%PCMN6eu-WlqUcKP2W*o^gwk_L7)GSvp%ub~iDHau~LOa_vi%toFnl%GxDLCZ~xx zl=aUkIrd&Lhw|*3mE7<+F^BTp`zZO5JH#ByO>b55f|rRolv|dSyy!eJhw@@*Bg#u| zSMsy4eH6HFl=6xviaC^5ovY-RXT==KuRxnnZumeD*#{{tb>j$`_#RC||lp$yesZ z9LiTerQ{oL6>})xdZCn4AP693_L1Tgl(|nSx$AA>6qLJ-mE7|@aSFrArt;cmA*=r66V_1m3xf7n^gM0+Lc^nw-; z2QE9Xzx|YHAD3$PSJ&D^QT*FI;*^0xmGy`1>pK0ZRb1$FjrHMR~JHP=Rd zd!$a+C_5@rr)wN8_L`m=XpPoeH4l$R>uYX9u&OGs>XNpVtecctOO>@8H(sOIVy_Oza4%1BSiqj-or0aLbSqJKu@26epE<+BF zv!#4FQo&i)ZKqnmw6r@~UBh;G^$NXNUuQ6&h`M{?6szUnTAhrXOTEzP8lB;BYx7V6 zRi=DkpI0mgl`eM|RwY*r*VdN?{mF`VeL5v_J)rA!kF>L6(`-DnIdY3geY#~;O>O(i z<7-*_Xx5#MtP7W_8wc43>SK5=ZJs?G9-2=bPpfctCVJ|zD^}GX9=uOR)io;y!NzGzmLayBT zm7>7ZMI!@;J(EBT{e$n8+e^AX2y!d9h%B({B5@TP$cvo%!=u??wC0~_Tz^&++RJoD zL)^&3JDj+TF0_{^J@Z)KIrG%Qx(Ak)nYFv-R~{XyG<7PDig!eM_79L;73$2Is4aH) zkCvGwa+^9?U+Rp<9m_Py^}FT%lI0g{v79RPmKtYx`S{4^ixtJ*a{dnr-OIexTPjDs zz2rItbYZ)aw~pcxa}R62$3?NfTyecsEm)L$OD^x*-iDu1>*s*(ur4oMvJY3mVcYd` z7cQ!lF0Xzok9k*7-d@~zQN>%nSIbgfN|u5vwtskiwC-QCc)jLDwEpUB6NvPm}V!JU_V!mlt|Q_ETdR>;=?|BbWmQMj1a1|8egy}~V1YsS{UHDze#z(EvLZ_Bh-%2XzH4L4?p(;6Ojtn{8L@U=Xzta^c zg(}OQwT^h=@83j{XI1n|t)<)_yn}gt^P6`tJKUc@^V_`+P>@+SRbE-X?%sMgYfscc z@y+^N+=9=_jpc z&x#24$yl9RdYOAvb?JUQlZMw_>M=`@6Ulkr)uC` zgzE<%&`MJWT^YR7D6edn`b*KnEZ1Hvkhc~#=vGlBm#<~R_S(pfYZ#^6(&cMy7uiBp zl&haSx(TR}D|H?C@mYt9rGL~qoLG^R$l6aBjgG9Zc{gfQE$cmA-sF3GN7b~Rzn6JU zx~Kam(k>FqkZa_c_WOlk($ulsKgp47uXg&D?Qu%fn#SI$lqN4l*y&E7ea^SD<|4UY zY1ES7)r|3owpX+9Ve3%ucZ!_){^2nTSVstcY5JXk>z(c=>U_<8xNGt*Qmj{~bv>)8 z_)C_TERXOv-7d{_rUsf}2==VQFTZ`*hfvijw3iu9SHK_kR*p;LMNWOFZ8>23iwz8A ziB-F7wWL+<6(v_?egWiH=Wa&p%y!fri?^vJ;<>P^R;;bef}E%@h%b;#5bZUwTeYb@0QQcG&#dTFy&EvdC@9nRnvrE6JeUAHLn zmdK7(FCojw5_pRM7jAc2dT6XtYpJp=$UP;sTu9WO8%oso^1XHUv)5l<&c<#aQ>}rN zk*(v+3wR&?VJ-^ty1DxTj*$H`a_QJAv1{Wx+(4sVKo{oAbkmeF^3ORG5D z=kA@?(hi(L4E|T{G^yZjF)ymyWvfd0@)bL*mMq!d%KCoY`iAAD-d=&ewn@6YWXYml7vAtYpI$G^_`%}wt(~Fr>x>N=?Vda>mhY-}o##tb z)h1Vns#$T7TZL|G^d($=7<93}T*Yo#*Eepuv>w^_HK;Ve5R09kl{C^avj>nE@_!hl z($wkK{(RY`-clXQA(MNOF99WPZLfW*Dy=8aK*gonr-fwQQeCzqMS)Y--wmut_5$3s zato;o%oxAiw$d>r`#lq@4bW?iF$ozXn-)Fq-&#+?85V%ju!v9utW0 zS{*#dl6E#j?N5=*xcC?Zp)I46Yvl45kH>IF0(}+w!^0FqOHXQc2OazVK~+@hqF&yI z%8e93Ra)ZK1}>dFC~9MgTid-ACo4Di<3#D-&iRFM8y7*OAFiCTyHavSYHC%kg|@D2 zdDTWzk~7umT?;uN`?k5Jmb-nw<=(=@mf@DZthQ0hbw37!nN!TS$Y=^}mRn@%Pu2!@ zK1^0sT3V}f-LSp7KA83)8sV*ZvSt-K%avDGZBtuw`o9<@Srgbzw||JLR}|QFGYz%B zd02uJ+snEAH}p14{|%`cXR9N;nJwFOT4vUsYdzynSEmZeGEVqT)kUSLbM45!sg-r4 z($p#6sJk`%1;R*{jkH`JDI#kv4n4U5b#2pUN2|y|FI$2X+uJBTC%8w>IY9$c(os-u zpO%@myVgoqCCAr^F3T#quZ;TEpFlEe2(e9%wVo+5Tc!PH+yg<&%o4f9f#|u@SyOJ` zF7=io$JO0hz9gyPF734_H$~^#%NV7h|)qZ)s3Y-hNyMDHgtNj4ir?9I#Oe$zijW8tRuCimK(0et;yU# z&Le(x0;#eJ>dad3cbOhBTncrjMt&0AO4hl>rMe@y4Y%Twa&x&lUmtc#v9~8Rvh>1r zjHb7H*|gJLp_S|cS{E+r^169}s*6b&l>;Y@xX@@#Eo-YXccaR>9lPWAg;Jr)px05~ z?(uYCu9D>!K+p2_nw>J&I#a_r53+_n5AvJu=Tfy=(_kH@8_>R6f3qE4O- zExyvjp>@StAjS&aBb+L^vZyoax&dQYO|C5J9QK3KP^r+`wVbV~N{ZDB{J40bQtRkJ zNVvjNhKhEXvqaaqTQT)ziCf$CuSs=Tr0RFO>)<3gafb_xR@H)xi*_yX4_^)o#+RZy?W*HaB?klk9`94VyBl(ZIWOLb9? zdNuZnX$h_EoMGtz>2i|wv~|Td>Ydozqa{V{+`F*6mhv)3OOA-Wm3)n)++NaYUH*Hf z>)5$ePpuUl`;Ok(2d7jnRSeD`RSQ*7Zn}R`js9PE{-m1Xf7&isuRy&s9K&qcDah-V z4AUqpF*>r%e2fN`$^Nm{*a26oziXd}YV`ls@C;XLzMK0iTW7xc7p&Yzv?KB!#H#6B zRJx|Vs-%XDy)cK>Ez#@MgEFW_|6g>+86s#r0FZuSKc1RB<;&^fvgI&n zXNFnS)hH|L%HOtPkVRb$x6B%1QBi2rW)y|nL{ma)li?MvR({vxD9GBhPSyaglnkw~ zRK*wjmsO6NfN_wz)cR#DMpYE0WatFh1q`B^aSlaY@{5S8kz0V_2NeS?vcE>D>(Hg;UAHWOyY`X+ z6s1K}NmrJyLhX$c1t^wLk%8iyv$R^W7$iYjQK;l{>I+>o*W{%|>PCOXf8^K)8kTUB z`YTzlTt@CwF~9+TtR{50gj~!YEkV`J&r`7~saEw$hf0(dDJ31$;2Ge9W#c6L;ulSEO2*NCEsj;3J8c}>xpWeU- zPc0Rs54!m-|0@PSm~HDZ5wcv5ejpXJPS-&H!W|G%QRu13A+<+C6g8a+@`#&J4`#oN z4wo!OJE@ zE}ARUzhIQefm1^vR7uIehmr!RQiB{!llCixDl>x~%y;=89r8dF@?U3E16j3GV%PQ# z$9`R%9uYFCfv(vMflzBTV;byQ#Yl&u7CnGC&Ozy|VGfo`e?jBv400$hv$WO_hq4k| z2kvSS6)!2EDyto8n1yMJW3>0J4ddwdT7!UcsDWwHCMBEJ+fnj?#Q3*%3!+eJzG7xEqJXiz2r^85&SpWR%uG1$PTp zAzelfVsMn^tAm0%T$%;-wRA6~(yWIJQE>N;6q)*X-(UtW_s8u56zV|RKe92-<_cdWY=I7PGPZ(9*$tw*6N}j9i(9EifhAq{KSD?A_fM{= zP*Fs?{MJ?}FSOdFcQ@ZLw}qttv4Mdc0aEU4&FXzzx2$ST>C)x9n)grkmZ+-jwF%?& zma|10loz^d2X)PH$KZZ>JFGB*y&Y%2N_XGXA%hR}zDb?=hDN~*J@ECG#`)=#yN1zk zskds%zNpR_#F|oX)g&2~lKQ07TFP_{Em_DEl4Z=G0&fXZWYu>ME)GmE$Ch?|cGgIX z^ctnI=2G^`%a<$#%39W8ik7)8vdZl3k&Cpfb)>j-x$51tuJN*EOLx+}e&wF)9_H?9 zoU_vD&Kjypsigjt7U4?fdkI5r$u^=WJrOn)8FhN1I{|_ zLU$Se7@N@qPF=TE`B(x|OCBVvuY7r#qb=D5b-0!PBdw4eiQw%3Rx`&{-mjI|I<42+ zMa|S3LQq+36_nXXT%T$Y28W|gtFZIw}Tm<$}SHmV9N z6|vC{TDT@sYAr>91aW7fQ6xz#>0RtrkT4hJOC0MA^<=#E8tdeVWE#->S zhC6%eS1`+xfdY=we0917xNCQc&2oB>fTfaO+E-k8!If8C(cXXQ6E8n_F(t|=p|vlr zsc*_~32O)fQOJM&ZdIPzDCqD5SDSw?1`U9}K^k(g?xrnAB{+3~)bhGm;M8?)pvj8$ zT{O{oH)ehruAlVC*SCn?ZD&oTs&$Z7l`SpXMhbE?odE~V%H2w(#pN5$kA_;pj4Ch) zUxc#?&{|g=XkYR~x-zA}HOMZ#*qICr7=)%tCAUP^rh^b1CHZQNF);fk*XoQwu$OXo zK~|Q>SS@S!F)=!`7O?1B0L6t7|d|X+D__!D75dmfojZUs7 zuTcyVuyynsX@0Q^wI_ptH9#O=CfDWPtlP**v(psaGb;xi4^Bw*>*nUcXcttkFQ*Dlf zr7db*T3V~n%39dlu4H9Yt?LyF>U};a`~4PbSr3x@7&`18BYn;eV(P!p%368q9CeVQ zI9AL>QeNh2mtmX)7&CYf64?>5MpIs~Wc_l;^ueNQK(W{5Tf$b#+Is3OtUrK+VtaYd z9=e(G3Ub+twO^=@5!qTvX|WVcH#=P)58=jRwV0@>v`8!SpKY7wgKgME?!?2YV648Z ze-X@Aw@f-S9cQ4fS#rKOaQn6;7`=aj*Ns@O zk1ISAo-(Xn@MvQ(3;RW1=Zoz{y)oxo-kzc!JP%5oR#LAhFFxTRHrIBG=PnhMSmiwu9B^@oH7oA;)T_st!3$v$75z0sEC7 zOL>g8Leb2Y$~yA+AO$m9?qRPa|AyPZ7uIQs9q``hIY6gMK35v>xlcW-oAS9EjwhZ! zAmaa;&jq;~@OB#R4eZzb^K*^otBlX0KK&&1H1D*$_#f*P|GS@e1I3KMcf4|E5~!9(S5b|}7mulVQ468=+2dSRE{MfX zywZgDe)+E6TH+b-PlLx(HNsueJ^@p^W2Z#Eu*UcR`ciAW6U?-Hp*225?&6Jbuuql$ z`LyG8d=8Xfol}P&^J06TH3sWRER5Vl$=i*_%4+M0$8r%iwnVloOg+mQ?}a*p@_L$f zY{&Uf=V*Do-NkO9O?qrzr_e!*Z~vd~!f&_UYINqmtR=^yswawp8X3UtDK72`|0%8% zL+~}f0z513+iXFPpR~{-XHXs~+`>$uG1j-x$ktor%68&eS9_%PPzY?WB3Jz?3xQXp z(#*qu#j7PA5C4+ZDyNGo!XLw?EVX2JA+Za`Rbi(+j+4S}PqPcI9lSORyV|oY*hK}4 z-5p`ZZT*-W_Is`7azQg-91YwZp!DOAtb9hGnYlHhfErzo$)oiZn;SJmennEKjC~JS5vC^m(zhW99Wc5BYiJ z^|V!fAe^bDG+$%W45{e6^CPS)W~v`7>7`Vkn``i+B{F!os3t8hVVjn+2;UV(_%5ID zkHoXIUs!g*R`U2~Tndtk;Yo6ZyZO=9M(GpLGcWr}_TsjJa<1CtL@OE|{|d5TT==89?{*=11; zqi4|^m>b;f$LNv|Vq$dn2iBYVAWt?l(=n@2`ydaH*F5z>v^xhSEzyQ|?P}0gJBHdS zVsRaqD@?HtdB&>z5Kgr2Dx2%5d2SS~lcUBPlksEm!wAGGbwu)F>2j&C! z_YmK#^q6e7E;{|3@_PDqrWpHoQ+Yidoqi~sv!-{3PxAOCK`Ti@yuQf8 zVE^%DdfuHczpJ;FzyV_}onOwnn1mXz`K^Dms}^yP%);z6b{liVmn4pZN(;d2o^mbIQ` zmqW9O{`>>U$2N8uGiXhHkS7wFoyqs2w$Bfd*FCk*kIFUp(GrK@-B@C$<*xVP7IPTi z8<MXNv&3)+ zeu5zwAF>*?Wxlt(zNuwCGuPlpOI!}`$}$73=8>|tip6het}yY7XJR8Q@Z$-;I8j~9 z7PuL|`e{XmUsSR94a^ko^!ddo*NN=!mFk4c^L{cTb=Q#X)%l{$xds=Z@R@Vty1~hTsLIknb(=O!$-pJFO;Ouv@~i#erGDlI66KUPzX58*BzyB#;x!P#zL*J`zmwOz#GIxri!=+7aO?(s|{jx!VJrIc&9YGU@0 z@g5gn#!8=|6!N_#E`!g)N&~di(@=yneT~rkp6_d<{GOqglNGr{(Tk5UfafT8r=xM) z1m8F3)ewA+MetJ!f@zD1HMZ0&OB|TtOVKuYUaC9{PPFY}!t(l3+#Cl-DFr9k7y+*0mt%`BBK%IKYl}Jkh8{y% z#s@^gD`w9)cxFXukICbbrMpa&ERF*+cxfhrT8=q05nM<)E+*E9oaNw|2o$zOt3AuC z3s_7CX7v)&8_x6v4%2ej@}^_j9jvWkR|PDl12cUox?IaNC%Sw-VS2SQ?XI-tZ*bH; zM{smmqDxxsT54Lv;yN%Fm|_~WTytU?KS;P9Y^s-=P->uM8RlB?Ts{x;33m_tIMb^idb9+ zW)RbCNVQyZW<%QRay>kn4MuCxXT*bNLz0mY$#&85Qo3~^i|@c}V&Z$l`QGF3-5m|l za8GbUG5aIU`PMBj&!JA7}xY&qKQ(rmdYU@;w-Rov~* z9+Q|hOmlqgU4&^mmv_we8htZ-nFz^lrI7C}(Sc7BA)&2y&9zm=B0DtS=*R!kcosu8 zr{C$KLpGlLn5k~o@6?^*T)N&$$>KOP)0oBrAZJw(K2F|zC*k(z+!7%??UQW z1P5jnlfNv_MU^$?_{%#e!5L1Zscwj3_AHwD%hr7Sj#;+KSY!ug5>vjsmTXSGd^;gK zpOt>HzSJ3yJIAB8)6MebZp&Sp?Ui#V-xZi!OwZn|rJR$4`Ti2h^8vO|Q;t_WzKl0= zu2RVNmcS&F@kR=YRm-aw&r4Z^hh`c5h+gXVWa1tiJHE{)e4ODBm|ooRkKp;BWvC-3 zyl8m^;<}i{cxa~4f9^_R+%V3u;@{^pek417v;z~9ZayoXx4Z)JqLf8=V6JhWZ^d5% zH(e*1uXLbp%w&Y&WX@N5lx&yGL%OT@!Ney9?S(owme*UP_0ESnFD$R8lMZLV0!`;D zJ;x_J?}*%98jN7VEqKLz&-sY_AR2$=vAIUI3_A^Y{)&ABDu8z?vA7S+NAB^tPnO+S zc8>S*y*~HFppvM0XL&D0%PUCN#Vp1HGm|OOBJGkg@&5d$9LCQsVZ0b+60=QbMOrEc z-sB#VyAz2eY6hYx0rqO zW}_`}Ku+Fj4{cJ!;yN%7n&!~1<(kuP_DqZG)m3=>Rn$y3>o*Jj2DaGeS*ckp2j)A| z9NM)kbH*|}B4>HDHfm3^36LB&%i&`gbc-p;M#HmF3&M_c78Lehf z+vD*5-$iRF!dk~7I50n%W?|iMf*)=O-aOB7z7lA4p5v@lEPexXkBQ$6=Xaj)yJ?=| zEMc{ulbxHc|F}PiZchp z!wkReZfDrd1_SKa8nq{ZQ5$@jzEBHFA>YXpaS>Y5YR8|TB`m4~vxw>G zoTrmN)KDEY$-z%2N0P1Jg#6B;HZT{M`s&qE%jw7T5Jl}3)6R5#(w^X)b%ShG&G-~^ z^f!zOTCyjobd;Hj2o{bX2yg2>Jf-d%gZ4r?`Da=Nj_KGRamA~`hcmq^AF zQsqf=NPeJ2a(7`F*1wrZ#uob|OD&7!z?@&ol_1EKBy(~l56~o!ryU4h#Y}N&c111 z(fbpE@#=_~;Co^N;AK3DdHG$vwZ!A$pTeUUTcHh!H1BD3I|K84$s?AhVI%#B`{nFT zvSAPUvt#F>sQC@|h)s*B4JKNa6%Ne!B`aJ@GRF#^PDsX;Zw@PryjqU1Qn1(!&Gz{o zM9TJ=xCEzf@_lo5;be}p?ok*#xHjl?7G>U&YkF{kgveGJD@^Bdgv0{L|{;tLqz9j#I+4BTBj-4HR-uD_%c)f^DP<8Jn7P~K&(NQG6r0Q) z{>C=#`|}+(;qu9oF0uOQof0H>{I(HxkqOHX~1=cMXh zkCTT!wV?TMe*)pQcCQ2d6tlRWUl^Q+KA1VJwk)+<#v(f~inOG#}{Cq@PBMm^(&J zJa3ND9Jy`Aj6S~1-QpQaA>Ui#GWg8z7LjD%CNphuU^X!IhLh)^>JE{USJ_(73%!){ z;UZCc7s0*Z4r0G-*<#BOYbDDH2j&M;R=bvCPF8!?a2z$i!C7tO*S5d-okeY6E--n* zwbXJv;Tc8klh(8G@%D5Do-x&nn%-bf*lIB`z_y-6b6|FGVPRgq4xQS&=@fZp@p()q z8aI8V`tg+`=1=Ch>1)V#$#`h*nNlm|^%i9V;SHY=dp^{uct+Lkq8`Tvw-n6>)~B&V zD5Nhd_gBqQeX7ht!yx_vCz=D=I58es0xO@Y{+q>>qwlvwkeboCt)- zX&#T3GF*4e(c$18MF(VSDZ)y@VmC04m&Su2UX|=}#)JIN7WEs9&oUa1Hpy&32a48G ze6@~6aA1xuMbK&q=0woGl@r|Q9%)bd*GF%G3t!iGzmJs1OueYvyI?z|EW!gbb-VpJHq)#u zCR2xZJWcy{ezSydyo_R|`+m|6(2U*oT%%g{boemVy5QFeUr_9u1Ts$5k&Nwu`MZ?& zkmtsUc<6gSPR#8ahUus|4$ga^m3HxEQX819OFnZgwH%-M>x$aT*Ro-IZ3Od9!YgJg z9PBfj78BQkC|MpwVE!)61yIW|CwlR3g?s>X-Vi&-0-eQ~LLdoJdFrSzD$=7nsxwHE(!!bNRd>w|Q_KzaWG5Zw3 z{p68l(rO22TEe0_Ft4}Ee`aJFi)!K(oGkTM6xB}{jgG9ZsU&sOMBi6l_cT^961NKaFpBq)wQ-X+D-w3>BW74*}ug!iV2~vvd^48L|;-& z@1NiVTd?k!J?G$2OnGaGSuQjzdIK|isRvxGMdr}^#e!Z1Z`AY#_ki0kFI5X(IYTmw z-M|c9ie1#Q%kd`uqhL250McIV^oNmK;NaNB{)yFU3ue27MRj0?FZmO-RC6ry7jmk{ zo64V1t)&#_8Wz2QdA;OMY&gCDUeJq!EF-tY;r;|Zs)}~4*sl~Ub^~*I$?|SEyPwb5 zUCW1qY>qoQ)mmzKa}A5$&`h2`|7Pl=X>uN%84Ld{r*{Y)kTI*(Ud_gbA(a<1#Sf6z zIL&)3<{JEHi8j2;5ZZpH)f8v9h{bhaE-%f*DbG(;e2v5P=UlGy0BX!!2hYT5xc0-w zei@7Gl-WaM9b&baDMtPOZ;Yk>Y(aK^+V2ct02G9eW2QPdv$r3fu3fa)veZP)VmUCg zm$KBgR+^Kg{#V0tF&)e1VYz6r!?IR$Sl%0$(MuykYFXxt4EYzsa?}iC^bucXJZdpV zGHP35KfLGOa~~#RF$rn3&#aLli+ckzd1*cXJO!@Tv0EzPjnkw4j)L0dQG1e2qb3)7 zWaG<_dzMnj_m+4PeCFilt+nVabS%3Yn9tke_u9M#oX8W+g4I)wrabc}a~7;2*>2q| zSjWoidH(S8%Ij%@Ipe7RnGlQ*$btTD>)9Z~lwQ;{KS)wbY2KS_RLi>XVQ98m?qY2h zviJ_n?CnkwIy^fHb3MnF=9?4A_$P<&;dJFlc06vj8${^9DkHvmtINnPidb9+=KNAW z48*#U>(imE>Ffai=yDBIPhdSU$1?Ex#+UIx7L-E1x5P8y)3(_|+3HfPRSApg&}^XZ zjob*P>qOqj)#O+FWO^e@WV?0V$e_HQ=ZzdKucxgw$DjTOo9d`(Zst#emA3B&mE~sM z5e8-i(->80Sro{=zrh)!`uBujHEtwsn;bk>!2Tf+>pqT;C|Q;`Faww(8?_vBEb(Uu z$G!EqpTXD65@Ty!k3#BL1gA_NqUl&z&zJb$$n^akB^W{)IA1`_-f@FWA6Vj^YOx1$ zu4b{EGJXG7EPtA?T#Vq`JS>-W!vMq!HHYOrftkM42vWZMen8K5lnKiKJ1SmQ?e;6F>Nuy*iy4t4$S@S^>ZV)f?Ii_ zXxj>jQk~3bTg4M=c1a-N4g0w5g?+=P_~1)@=op0OA>UM9PeQrBNoeBy;*^eB2@Va0ZXK?Z*97o#0U>%I^Sfi&mF0 zt;<+s2W9~i*&9yw-}q!_$2KF`vegx2t1=eZfqB97+?`soIsHXHM#=8uFwaTWoysss z)LuyNb9a>8wp#A-ZI`kL56v54B9H4acFuV}te6b{6-9 zW(^a`8%^>@DamB@|Tos zm<(yHGlm{_aog$OdB&A*QMB5_S{JaG4$K;+QC1ty^oI+kvuCYmlWBW0?a0Uf#q31~ zkFvUSY_-~g+Ad*H9hgB(W4>#t=EU&+!l4?iljFdGqL_SpT-C0}d^;ai21bP#BBDB>O*H!_G>A;L)>Z@04vpIeB{+uw~9%lW+ zD@&vC1RkZgK8&9227UDaVXyTr<9-De>w!7OG-pRG>zo+L2TNIx+cycGv*XgS#W)>` z=oPWJ4$Un3PpwLQP>o;0>ACl3lbTI@ba@Yrw#F1FaS)l$jgI5e-AI7ZGkGDH3W z%JH{>Z{3h%XQ~bbw^VXC-W8fv^vAy>du;46_J?me{^d_8$N6Z|m?L|5uZ%Avf_+vx!w?#xc{EiT4 zRxNf=&Xp{V12c!ohpy$A<3qpKaNOzj#^86v9d!<#Gwf2}xM;CMvR1QL4$K%XEX=Fd zp;LP|og&XG&Wv%Q**&gQKgsf!`DD)SaShpS-CVkK_7PHVQ8p0XiYHx-%h$KNsKarOEc~i@O5zeT#m7 zjT>QSPef{(^%>9Bt+(R4`+84KYG=BVjgQ7cE4HFw)6jbFym2N5cP43WOI!}$6z6$s zDY}J{ERF*+ zc*zpW^HIey#}eOebG%6`agHnXBnqy1zQkf^-p+r1PkNf5=~2PS+x>n)@E~hnH}1n^ zqLURE1_;mCj@u#!k1V;Q@3!2s%w8eOLI-B;_U`jyYH7w?!#AfF{<}QBN8=uh;O@1v zAwnMWo!>lOr0_Cc$AwBE-&=i%%%?H~7h zm9#Hqhx@~*X)mH0hW1M&=jyE`o(2C@(XLuw&wE~nMSNiXFZDZ;C#%W>=lC!0tRfz^ z6tis)?sr7|m)vsOez|M;nI3vzRxphttRX??jt zrxjS%JTR}g&yNcx|K-m4FYl;gUHv#m&HBToWuV^rMY#q)T4Dt6uK$vwT<5;nRam?S z<{{I(9`bx`r1$dn3f>hFs<+9k-0EH7eMbH_=lr*AnjM?U5*4GL5!-s5X(!j94+NSe z>=&h8xE9d#vC^4)P={O48u`2%^s%)@_I*)X&6kq7SM2kn_DJoa+B$Ae2u}1xfn4Fd z6oo9l?M&qY1X*@$-wrpQyLR9mDEz;BadCcrcbZ{Lp1Uf(PlwW`_oHts;Tty+vu7SW z!RC3Mp$9LMf%Sxux9cL}moIB3n@tM}nc+6aL?l_CvkP1gUKQ63UsCU{~%}T=e z`d)a-2^lXO&uUYv{nk>#l@l5>;du9rFB3t;o~XsECHnBM=Ya#mweGhm=lCW&?aXH- z&l6NyqR(ggZ7U0v+HmhF|*t(1~MsH?eVM&SWMeF$;7mb z=z1d+Z%|J2hBEz|4%7MLnKv2J?jxF|3xcropVGY3&OIikPae~6a+vN9moX)`$(WX{ zF0<3BfMuuc{9+~3d;H$7DUxS=Xig;WHyoz3@pz>(>}L5GWZbm8 z3~^G*A$%b){xM{V|HYsC~ z9hhlMvykBltGtio#Q5Iekd5n)nd*iyzAQW91*<1g$>KOPm+1T1H^UF|iRQyOMB)f1 zbLOUN$#%(%OtPOE@`5um?S(qi@_LQqAsh?+dcyHI>-09Cg{G}`Ewoj}B0Dgjm_{Gq z1yO0CIin9==aNl_2g0^uw${x?A4rO6>q{}WDzI1&%s8ge2equvLuu1~Prp{h`lcIw zV6k4_{i&=9i}%3HWEy=?%R47>a$5!OxS^Qsdb8076lBjEw+mT(2WBZ#Kh|2lInnQ5 zb@|T6O5w~8G4tK5AFD)|w7k@9q2(;f1M`+?hLc*#IUf3JD=5#MmZ(Xemq&|62`|hw z_~FiQLP@W2T5{I&8Z6oaGny$DF3*+<%=k06aw09iQcio+lsAio6Uxio6~#BNzw1I^ z9y2{(rj~5%wcPaX^EE!%QB#e5CGll4JQdHjlij9rs;h|R(YzxtXPNFT<(aCo)0}(D zU-oF$gCwJ-nsIMgHAqq+e`m%>?g-3Wrk+)`d~@zCUtPv`?sCU`Z`rJ8l}5PE-M(`p zBzJ^nHT~HHQ&!XT9^{N%_@xrY@j{B3?`9(x3cf4c5*#_nxqsXdn9oc-PHOEor^m^w z9HwLExmk}BE&3;jw$_Gm2|ZY~QgTkPVjlq`+|vyW+9LM_Lf2*@i4$9?C~3Nd@o&Bi6z zEqB3oN?C*lW**ZFI<`eOJpQR@Yzknb(=O!ze85^{c_)fHr8 z35)8$3}bqtv^+0Wk!wyK=I1@C<0d-ziPAC;qlm7+naOfsPBCR+YFXy^ATOsZ%V5@K ze7aMgw%jw+Rw2h$Zx75ernz-$`Q~^aKj-l+9gwI!kY*8T#detkBDv=JAKL>ni)jYG zTBbSikC(Yj!xm!psL=<*m+`3UX7H0d`|bzA%=13Br~DxveaAyyL><0x^yK+a_`fkr z)Xx%<4;NE?!S-UNxtVp=t#-W*Q^4{#0`rGyOaUV9vcFp@;f>Sp)s z4X06a-E2$&;!9gzhPPGDqC7Oan0kKHQO@zJf5xGF^Ud#vgqP0mX9`$M2j&&ivr(my zcDxpCx#yv@Y5(e%I83jNCjDuDH2ij$tKkfJw5X3=_iR)|*lm581^4Q(h!4#`rf0k3 zNvtBC6aD+?3gU4)G5g@n`e0Mqy&Frrki~as{xNweb$oNYlovaEZ@w8@5#Q1oTTKCr z>A>t`%BdsLl{TBh^iMfVA0Cg^*I*kl+v{dIbwpRSy38lZOITEg<{|z0(b7D`W+VY8 zYI3VXHJNTVYOoN{B8Ty%`|?>ERq8=jw!}hOEM?McQYkf&g*3!s26jFrdf=y>$Kcs+bw5N z9+-nn_lmWYbM6&?j8eX^9JQC->|U`8t@UU|9gE<=eB z2ON>6(TUi#GWe9yj=Z&m-$KKocW+=OG0g-l z&qI~J%!zdTXio2VJQ}wr({X=zIBJ413Xd;CaK%i(7t_$irdLEwUIPG zpVHhNbS9Iy?QwA2PSLDd?7^I?SuCgAAVTUe>Sa;>H%2u6h-Nu|jCvb;cf`$eaPK_e znYP+S+A3jD9he(TeNJmFG$-TzJdbMV->?a(##Wb8ElXHb2j&ZR@A2*dQ$G%K56GDz z^|>C^%i}EaoZ$oHwNE{1{j(>p*EYPXdqHEXWvk1vRz)nX19OLIPA7TB9A8EEQAM|BZDByV{+-9;gb@33s)p6!0@?j>-tPt;S1_5?baJ(VhY7J1K7 z$M_?@9B#F-DP|3MVR=2xH%6+O#_oPt@qJN$g5y9sYb)(x)<3+mG#XFZ-O)PCvk*7u zXX1f{mx+cvPATMjORU4EwBa>JfB;`ti$#9QF5-ze5&6$M0r{Nl;tkd0M{U`Ivx{Xc zQ;)p7oJDz9b}`v^X_VZn;ZE82AMz;Ad-!yE*LJ!%kIv?^@9q&Ox9?sp7Wsi$$>h09 z^qt=UO+LqSe@+GYxS>tqxfARQ`%cZxy|-+Myymi`!n=flZ9k>~yl^1FXB zJ@;j@-MTRbYvuJk&;9!HdYbRkfXSww`?CwaSHV-4y;|euIylpFQQx%KGTlVYVmUBt znWBfawweVn9=HLdz!(mXn#1(#&Po;96fYfO_=tISX>8YFjHUbTCO>Lv5yn3 zCu@U#?A|v1PT|W$Q_fZj`Q8#&!KZXDB)F=@F3!1@MRH))GChG;o)6`8_~XGi(UM~p z$(`$l?bY?cw7)ipJjW9}r$|n;)p8$gyO_mzU=A}`>srP+*7`b^ao9r4cZyA|HNZ>b ze};HokL*2xSC?&anJ=o~DNe+JQu3{Ej?Ad0iWLe~}?BwqB#F<)-PlwW` zF^+Z0G0Xxp?5sx5a_}<^6w5`cJ)U&|i|N3;WAdbHndW%XQ-|qHcOHt{MmO}N0bkPc zGP-Foi}A3mW3t;4@ye_t$8Jv?#yis~MDyb2ySd$#tu7;56|k5N%qQ;lXH`u-T<=^D z*D+ywoUM*v77_W#ikR;ZF|Ud*6VKBrDbTh=2i{FQkG9&y+A8Cay*n_Im@?&f!YZvb zCsY0`pX_2H?5N`(!F^n%r=1h*O@>`k$l^ONyO^ROwS05pdTW&L&hQ9sAZDxGEE+P# z7JKGeDp?$dW)uCs+NsBf@jy5nj|j)tj`}#&!Y1Naw%FxZDOnr`<`Pq$1u?7iH#i&* z3CD$_5wksRmS-tbF!&GN<3tDkT{rT5FxL>{1;w&CU8P;oR(bt6ken zi&$I-<_}ZerIu?>{BGcIz4`Jk2(N5)8P%$Q#dKgUG38xqndanOjyOz{^g`5LbhEq* za!p!ZMmH^HF&>y(Om@4LagN=-)?s|}eKMRs6DF~y~8tu-eOvf_}98;JSNu~}SNO^0JfB+5LC zQgS%n6_`IvGg#Mh%$dRZFyXid&(DpSVZ4sSaUGa3OnsI%oa>BoEuZ40ZjNH+x|#2+ z9@$lXOK6p`$PUaQrYGaplFjL})FWi)GqvRRg>hSLjBMh|_#fvgg?w)b9R6T>BE z4YyOuB0Mm+n4VfE&rg+4!g*?4*C(7rX5*%OULGw<`GvU#Kgd(-q?es@Oj=(-I<3K? zJuu^#o?9T#Ru%2oAEN0q}8vm9}Vvprq&9cjZ8NEe+ z?ynocNS)|uZ&xcrChghDeA?R**>2s_-sp3rNxel0F1!`bX|8zg^X{VFJs2!sS+G3p zW&>D0X3qle4e(_$AZI9rd~b=%;8XQ+?#R|!2rCVT-kpItyfiO?JP%b~1!rD@D-^vK zt}icV<908bcDgILk(enCo)6k?HG$bFU@;w-%}Y#gIMW9$reV&BO~`cKYM<$%fW>rR zRxjm5YMJKbM4ps0J;{bWcn0U@d0yd#ro|LyqGgdBnBCjy&l;2bWiwYU$6r1`NRHjp zxTn0%slPm*YgEe~4cg#GKvEc-)Wu3EuaXL{PhXX0E}Hmbe_= zmEFx-OX)3CEPhi4509{8Qya(GIQ(9w_`LugSk+!z-y|74-C6>$(Xj{)%;2RQG=lDu zt|P@9f}cPL-ZVLANvo5CHaZr;DQ{Oore}k%FVCH5f=`2$G|k&Ro)E0&=!x404$j+2 zV)GWernpeESPsnFrM{Vne5Ez!MAROavpg6~M=+@JI$VFuS&!hpnHT65Q<9C6!|_63 z1}|}pm~AM>`)!Vo;`%og$46;gt$-VpERF-ScF8+N%qltNc*l>mIgXm);2xRVstF!vz4b0m2pBcRO+1Rc#kNOLC|Q;`FhiF-3dF3^5_34d zL~}gqwpX)NT>obADDoED92ZI!$AQ_p)Mo-Q+fa@#)*K)1Ojoioy2decj1e1rnckTd z^HYFVQMA|wS!-D&2j=dQMV4pD$&u)|8^%KHsBy(23pe2!47Lp<1@O9BWm? z;d)1C&d>LwQ>58&&AA`^!JO-EcYSqz(3!?=sly{1ro|LzqGgdBnDt9N>T4}Dr$_yH zImt_E`q-%bjo=>j7s%F9fR%#9ZeYG|r*DOy13$GV@|mwBzUImFnXe(+t@D{z%IkSP z^SHd8_L=VnWHPwSn2a zL@l0z$`}TR+D8@Cc8^4DZ5vPvEw!k{?<{Hqb9sxtt-TTK&xvg9W|?J$6FL3?MQwlB zzOI9VpJR?oghY;|eJxr`;MFP?zbS)PVog0?;Y2;>Id^R5YJS&;gAo`Yc*V?cNCvN9 zIB&5{aiL^!oHBSJ9G_^mD~=uBr#YTxI0iaqhMU-7*;<=mrDE|Ln88cEj1lun@0Y{x zUd``h3iJC$%`g5A;mh2&ouw4=y(OLmpM?!pt+fHpbu5AdGj(b1OnEL;@WIb%oCc*$ zqYirv!P&Gu>_G4#YKlX~;Ax7B7CRtoHH+oI{M;Tt>wHVVU0shvo=#>2ZAi9T7ePB# zUeEK2pI2T_N6@ezK~t7@TP%}@gu}XG_ADMGuX<{k_vRY>Xo)VoQ>IDFeX?mGhwts7 zc{-o(l&3R!I*zU0W%1pCsVm~^Se{?tKx4l`xi|j7qYcBze>g8H!yFP?)z%_<@gc{nqQbr zXOrFc=@#1@8#RmNz-->GJ>Fb|$uGWhe(?^A<-_CAdfd+x!yec8GLg7#N+I7{;;Hai z-0vZ@s>MFcxt>LHU~Vr(G2}U^@{BoAjO`Z9wT>NDItIZD`vNn4$*-s-nB!M`uO?Vc2dtdNxGixLzk;^f=GiJ? zQ5~4`OY>dSQq37ZeYU1rJ!rY`mt&4z`g!lovG)Mi9kOX zxNq9?=zCnUNqj11x{Hx}CK7#~vLpN!8DdDu7MR{n>(5F1*Sq$ZzQ74ad zC`Srnrn||g6J?*ByTd}s;y5&4nEKHnXH^*%P6Yb94acL^wLyjxUc}6ClYVsFqQ#DJ z)@l~Zq1i$|_nkZsW0N`A!m|v^oxy-6&EjSny)b+k&*NOBknb%4m#pzToR&LiyQM6` z1M`I`8ZFOHm9^$XqrXcL4&$^Zqu58M1V^Kb))JJpip6hWj&RZUn$uhZ#zJ%EBsx>` z+Zi5*t0QJl1Fv6v8LNDTQpop~xC}n!{UE@Kt+nx$8Wz2wxxhp(o`@>z%c1uXhTcK! zne9gOLTep*QNyA)FcY}2;Pnhmb7~pe%bA_%3{7t=cDJye#dVCo7DCL*cWQTw*aa4} z1V-g-TAQHSyY5)FG}*p=VQ*;0&!3U#W-vM@nvv*`GECAwoy@VTG0d3!a7pS_!?pFL zL4UH6_sEZhTBNXG6i>3E_I{{_m+=<1D}{V-iKoLS^6s?Sfb14R!VfVduP?#cW46MfaS6#QwALXQH7t4q zvv%oOlC|`5?C^sPz3|MZ_3kusf*aZ4yu}X1g_cEfXm-xO$4l7_<58d;YTEPdL4@S~ z^_!!wy|lvVi zqIttOE{%h#rI`~!zQ3V)wKMImwB@gE+;@ASsd4h=J)pO^LlQkaZQG1&WP&oG&JMvXpkhy zWEZ00G;VL>A@VnjW~?8TYw)8b4#T_7Si3EE;P#4HjE80clf}j}RF%W#SnT`QjLV1b zY#NJ=@X8jKK&|vFngcU|DOQItSJKRh)!o~s8T)&pv5vZDMx$6A5}miYgz2J$MRj0y zFwI$1OEqWCqI)@1507Sp(OTSj?$9}lWW+;KU9`H4YhA`7J1|q2$lh?W?`f0W9SzZ7 zPolQhjmg%nE+N~LvB(b08m1h0E!iBu`W`mfn=1#7_PQ(wZuA_QcL!z*cl&pVX%v-- zgm65NyBnJ6q}oy2=?BPbo<>0ya}9p9L>u096oj_gG1FENi|fEVVw$B{o}a4d2dC%g z-E6L-<{A5d@TGX~UbdD`)i?OwiPa#z- zegm_G$w#i`m*XSfmGGP4gr50?`7vix8u`f9wD`73wu)F>2WALU7QB{gP8R$whUGdz|4g7U(t|HQ%8#G*iBdmX`yrOId^mW)hPH z-*5}Q)gxR#2s3KJITk!`c{$)kA&c+8eBwSo&UY(>3QjaPwkyQ; z+qd<5ooVOHT@q4wy9>x(sDm@1;!Az#dOB@@_0EUFo676$mJ7q%JV?_y4rV>R^Ipa6 zrNIcM#fsSzKO;XdCgyiZuECF%cow|tD0S|o*sU)|-KoPNepg`5G5IX=j5$|^CZ6N7 z%y`5Xqe3>H&r-C!oO4~uB0Mnrm?A5+gmWS*EuZjWs7TcIoD*588a$JmdsEC}JTO0* z7~gQlw|I;%@7vxUXE+IO%svZ;aozHAGj57mj0a{e_xj_+l5cLJEBLg@roOo-WxNl4 zSr2Ei&u%&|EdtHQUzls~qa{}1-Sy28e?f+AHzST4R zj!7oe9kZH?|E{2!k^3;`{I_ii9W`W$x}%;E+witK*WhmhXqG0ETp`y28g*~J2er5b zt&w-@cn7I9^1fVcHD5~JkDMawz+1`F0_IT-FLNgvMtjlvYT9)T7VV+gPk(O76gfAx zopTrZEsyqIp8Jg3f8oRx^Ol!GUKFzU4$OR}5tGt7RatY+h{^vZe8cFQ{^9k}I-1;= zeRJ%+gD+#n7nDN2x5P8y)A%f=)h^highh2=zBA2jEze68)tp|j-=ybvb+wOvM$AN? zCXWy$x~5kwxEk1Ek7lK1ksO%UOd}L(N#^v5{e~iWv^Hu_v&l4Sit$Rum$AzgBNTLN z3ByLmA~-N}nfi6hGgM`ZIRt-Q5e)Edo@XatS+te_tW_L-7X$N)*2SQfjP!R?}pR+RYUKld3Lg7)p~Za*0AUe%pUIcdp)Ib=O+5biB9~N zrnlYg47=H2AiJza?FENEkrtUHt+qW0TEJpDFk6_O2VQHDInM+Cie@^Nn1qa#0gZSl z@Xi1uDJFYj?&j*A2aYs18C2rPu0eS{*<%d3Dn@c0Ew87?wQ%ww|50!}o^~)K7c;}5^W1jI$8W{RM$IoLe(?pvZ`AB!E(l-7 zkHFrr#j7Ru!@s#7F{ZsKB+E@g8K>%4#?HVjUh;zFX;2q~9%rkm<#-SOuFmBo8}^`Y zy6g}XHNC-JuxT-|y+p~ezB>c+dCB_La?G*5pEn#w&2O;vMO3NdtG=_S4b9{E^UtI_ zo{2$l=EnOsMJ=4lan?Nw!~fO>oo*Jl?;AQd-W6`Ei5>QeSX>9@@>1WnT5HU?m;0Q> zb=*7$-^=CDQlqR@EPewse5rTwhV%Pb&98EbV~$0H_AW+ytXgXu;#|ifI52~kdQ;RA z%<+f+RTCVG^_4LNU=R-l-r?dk*R(eUGTbBtVImNLdAQ^&$g@%vf#CQG|Ds6k!h>xkmsSw`f~h)e=g4FFcxxi{$PLagr5N2c6fe5V16xSDr!mP zWGenil6ny1oSQ0BL0W9Q1*+s&+=al5Tgp__a?G)~|7bXl+E)n8R7g~br;vYVQ5%?F zOY?}=Qp@S{{tt@U>{;tL{01LbI+6X~aYHeCyrJ{`9Q0dGtZ_*pi|@cp+%A7UtJE9V zWa4mEkfw7L{=LPwd<R!QQ^ANSI4jq+rFe_;}<-4qy#du)eE{*K3W&Cs~ZR&@7x`c7uNX$NV=*WJX zZ+gpUf!`!>XZjc~1ZMb>Z(YkY$G84l$}~KcC-yn+!+mRMkX4I4JDsap_Bk-yx6>aP zokl5{`$SH*?^A^3*zNK?<&{qF5$AJ_YT4uAL){}H$DTcA+Tp-lU+UE+&qdXJA*ZLs zC-bujJ&om1kC=Um&|Yl^v0t@pEj7Se$FjbGIlz>yt|ge0JNbkrI2Mms+0QQYYvO0C zk>MuBR`+V#5t!vmK5s3l9H009Nm8G*o{f*Urz`MWC+OE0v%L-Vd94;3lWVIvR(D5W z?r*`LVIqxeHa;(o@NOED__$>G!1@%Hje}vdx@v#xt#08(;N{;EkA`=HEH2+>k(#o2 zcsw1?brE&=D&~;5UR7}G>Cwy_tNS-OsY`?YWTidqtVTYTF4XECSSKx}2vaqS<-jan z>L(=Gc9_>Jb9~*8DVE2hr7RMwi-$lx-Hck@(0)P(WJ?LW>N|_tz#Lr~%~4A&C&uvC zirOwbBWOGt#NscMlN&mk<3Q0`0M{tJ?UQ`x8*IoTQi!Y z{JAm*bZZH~M#myJFx!@TYSt3W>8bfwhG2M*Xf_^p1`1`^QXF@0<<>Z~r>3OYZn=ZC zQ^?{wFax*CpED)()HKlu&OP2oe7>XR8heT0%UJ1cN+I7{;;HZ{;~8j?3v_9m!q&5B z4$R4=jD|cX8+n)am-^hsVx0>X@lfEAz~2;e-)AT;W@5wAmN*aIZ8O{?xMngMfw{Nj z8RKEEjID9*>^>|>y?iYjw%0~5^JC1uM5t$MT5H%PI*zT~9+;C$BlT+u=Jeh9i=5!L z8r~5#!FUDZ%h=m9ltR9nk@}afsn$|{a}A5$z${#{zw$g(c?ul+`=Nr~E@YFZn`n}nqYVm_c{z8?H|o>BQbjtp?%wtWYTIIXIj8w zIxtJO%b)cefOn*=^{e;oz$og8IaE_X1jL6{2_!Va>g?w*`tKbvw0BMU2 z%$Al#a$x2zku1+gm4Cq@`OoBeeSCKOCutJ9-w)f%&{N;;5EpPSoO0CC&RMIPn#(JZ5h>bi`5K zT4Rn21&iIlTwUtJR?9A@58L~5b`jl}xee{ZwqIVP6x)Uq5}WbL+XHiQDNa#KEhkR# zCpoqGz>W55r$3C{@`lDK_D`%1s z$G*V4UGgGo+2wc7l99hBE2Q{tM4po1M_vs;?`2jvAFM5)UL^446yc? z$ql}5Q>`TyH&?LO4b9Z~vtiy0fzcB^%l428p2|KlC-Ygh*OKj$XVmVJ0KyxNkJ}4% zrsee(X}$BI&JE@Db{F+H9`GM2c8Ab?7_(OG)ogqiQ*|*jj58_X%VahdltR9@#53U& zqh!GCv*3QIoJJZzcYYAOBg1O*;0pQ?)Jm;s*4s=D^0X4l0!3hsW(Ll@!Id; zko;~*vDjke`}U{Bk-%S&rsF!$ zB6G%d?ARBWqe~<9xVt@ZIZ!I;pg^FcqL$h`M zjI1eEVR~S4?&^Nu@QaV7f!=HD*&rK6%`uMq#+Qjz=t~^5EzyB@Wv>BRtJMzBb{UK8 zz?|Lg6otbxR%Mw_hq9)9i{E9RSTh(-YiA%v1;Wu0X#7ZSqjIx(sSnz+yTu*Oz=~#I2HPjt~7#i|M#oZsbD) z%QR7)SA?I37JP&6-W_w-C{%WFdk1WuZExW>^TejFmS}8dk?+MKAC647eQAXSEW6$CE zw+P2*qj3Y9hhy1dmt&=5aU7V@OJhZ9Ip*{#db7>(;S3%k+l~BrHlbrhl*a+s7OgHJ zS{Jdn4$Sl=t~Z?P-}Jc7j%`M+Wvk1%Rz)nX1M`3BsW-J;bDnzhCcYkYB9%)~wAck&>sd4hW(U)lDS1w+?*2F<0biHX zoIPtjn@ro2X$Ky_2d|i|bm*9=OUG8LDbjWUhw0scnZn&^+&1!7#WctB_%)kpG)=PK zbIeSKj@#Bu>sFUwZOT|=2j&iw?}1=flFjiwZp+E;tgZC=s}mgX8MUPj_dRHfDbbdm zMRQ=rF!jHyrJ2+J?pF=X?P1nGys|VJPvBv8>%+LI4)1>l^m;9K==RH5ln3Sy(_9<1 zlyf}n*OpNZTZ!2l37u=>(y>K28BXYxu&55q8m4jGwN!IP#r_JRdbP6_HO-;px)rn7 zTGvKP9gE<=d|@JZ!wG&3AvktFx*5Ut)EbIvsbdiwnkn>W@k%}WP0xPL-QX`1f{OvM zF?$vFmDf0pM4yvu@S`Q30`F?v3VIdA&{zF1N(FMEX0aTYEli^d<$0-!*>QUJzgnGH zoMsVv*lnUwg`~yAtDssI$$|O7)L*ogWKMt4U(zJQ6KcBIWHK5Tk8h9KOAhWY3hX*9 zx50J`S$qd(40k230|BqH)EuwlRhn;@MP)S`PGOG4P2qI_*Sf_v(MHW-c~@YjFx>;z z+Gfv!{+OO^v#d(Eg;~+TaP&OJ52<~;+b4?1%jHNB{ zXn41X<&8Ai6`0Xm^hv!DcJ@T1UQN#M$s~1&Y`2coL3uro)T8C~G^w1~yM95D+L^9o zGNs%LA?;t3Xa1(}im%{l*Vn`XzRvP600Gh$n>GwtLWqz5!h(u7MLt_3uGtaRoc zRN)r1Mn2aQ?WESo)~l`NOUZVgBJ04LTpmC1peS0=Yr>bYw`VAYd~b=%;8Sv*x0aAw zXjpbOFmspYo|ET6LF~_?!J+r($@#>UBL`^LW286q>A{yuR;k&|6)bi`b9TPBn=G%% zcyR95UM|_aWSnL2;NaD`*$tfyU$@qnUZZ018=TJTy{w2D#1Yo0M5geGOOS9o`IKeNo2;L+XIH#5P4+YfBd$+*sTpAlv z%P(ha$j|2d4zl)j<33FHIaz@Le7&f>;Lx!lm-O9MQ;Y1Cu`F|7UT*K6dG$JUYVRhz zKNaFuxXC$DRD#B*PG(f1BHktMz;WO4{%J4lKgIy@<=n4%QHh(%>uKKtdyqGcpS{#2 zdo=FBnCo6U8{%WzqbB@e*Z_DLU*mlFUA?sgP6mll3PLz-eJSQv1rF{mZrK}}e{DA(XeON`*Xf_2sUTH5m}EZzgNe5p^7 zJYUXlfVSAX2fVF&cMgsn{%XbH| zyMuvrU1GN7p(6na-=yWGhMbnOtaxDFaIZfvLGoIR*TV78UtB?X?zBYhwaiPKKt1#e za}9p91O)4ATVKceo$*-$^NcCdBF|Qp&%%kc{8ah*j+$~tq(#~5a(AUDW7+Y*EM%I6 zqn7N`ptR}T=dC{3QB!@oJVMlVm(KuZc_~#yGkx#CoMgJUtfiTAZ}}pR=G^gyEye76 zGwv;mTaI#PBtI;yd7&2rGnRXNuRA^E&3N6Md&{3J<2!e`W9IuIp4EO-uECF%I1KMj zoDliWooPL4mKt?a%<@P=vzmUtsGGs@JW=lFkaA9CZsla=ey%0kCH+9W+|RVUo|pT% zp}d}s58|(JQ;*~)O3t*RAl}$u=q!#lz!h%EfH|N4VqiWq&4Z4(xp_~`G-qVXEe_MM z^Bg*#zu~!*WuAY%GcZ?~`ux>$%<1#@!PN(QM_YPwAdwC>sd4h<{A^t8&2~JY?|e>fMdQ7Y)rHB zNMz}6Am#k0BJT{$DJGgXoaUQtn)}1$(dM$vvc)B~S?O7}IWT9q$M3_MVs$1~$B9M% zm`!sw9n3I!jd4qSnf|NiDusM+i3~nRT<}oL(P4O8L%? z6vJzxW;^t$Z@DLJTJ4cdidb9+W)V{qua;|06z};q*HQD_EQ*(9N8CX4MCw=shvo=< z-#X<8jc?7d%s*lX9%r52=CjPS)sAJhidb9+<_Xi-fm+MV>EH1@hif{nFJ_Or(bxeA zFl~7m;8r<@@`b=GVj4S8OF3ukz;i1o-*jUKEYeFmGnLg~(H@v_Ok)RXY3KMVH$SQNn5Rrnd8y@^)93Fw9@lX*eP4NmsP|p|Y&n_3 z$(gR;naOf!PSPI%mLlJGF7o|sm*spUU(C_L=6917gBum=cV=wkLSR-h^_Qx((wyET z*O!o8xY;q&-Kf8mCb-7MzH=iR7Xq`EsefxN;T%8YxKDW0_m7QwYZqjfJ0jdMjSGRf z%G8UbmS#>bl4CZ_QIp)L7YUMFMlsKq-VvCGO!1Cdf;sVy>kPqba8d_@QMWUN?#nTI z8;#-}wAD`B+A8A2@pc4e9Ft|P<(gxej~cE=YuPYro*P+a*;)r=rDG8snpyOp%bdo} zm?#J5UU1zI+_xTW0M|;)*16Hh0=wl7)=nXd@4&3$?li{@n&_&LGk6!&bdH;;$9HFn z+lZO%MswWc_(H48xyAw((}CH;T|U##hZB6Fd7GZ0AUNssHZ7Cw*3H|rR$gxr*}_-x z%-ieB>*-EB_^aEL>50oUtRrTgF~Wl{)5qy-rI7FD>CH0BqIfQcnMrbBzA*LJljlPL z?T>5Z+!u}s$uexU*`BM^r>%Akv{lBk(Sg~+6oIZKn-hV4mP;6 zB%1AU1ZE7=ta`OHb3BeUhi2SB%rrNeRZr6FIUI;G)89yWLFC8rBN}_o9IHGs93L)b z;)jf7 zy@j;PSY!w06_a05OE$+Zxz;9obIqWN_D{fj|LO3a8@g10vOrCcw-yF|7bNF5z^>AAM&Ekj6Gb*NMm|kA!#?A7* z^8;r3rk+_GLilWn%i&$mzlW`LD3&S)zuWhP<{W)~Q~zo+CWh17scX(?FB@byP%&zI zjPXr;8HQ{6SLZEuFfOz#k^}RNX-++PmXtyE`&V=3)LSwnccH@?+#izLeb`#e@x4ZK z>iMmA057S)Vm&a|nEI&Jvd*#E9m4uxG>P7eZq!G$D_iU`t&}W|12c;$s#nV~C#rXd za4cuvB9F6+*Ji zRj+4xZj){A7BSA$8~q((Bjb`g#DFko3Ol|Q@dDeu-D#_fd z!f}UG1`cvAtdF$QTto{hS=Mfw?fM0lYH9Phh^}~uf=Y4YCrV2+= zeO#%+@n!XKd4)q#wfju-8(hC}{>IJg!R1R=uWfFqzu)Ef4EJYdjmt#8jMqJl(}zNpm4Q5h<+ZQ1=qk7gWC;$W7jKb)9U`WgYN2O(;Y@#IGp+j0mXK-ix{_(!A!3@T3i?Xj!kNBhGrbi@APu^l zb#N}{l%tQw=XzNHMdens7}4Ec2Irx8!}0zIK?>hFhYBWzX`V?|p{@94j(kIQS&N7Vn&w%TzM z$zC7K;CZ}ox*d$8!M*LflXw>NCUcnC#_ibsM*1NdmF2zEqCErY461hxpMb%==^zpJ zOhwUmec+f`*GJC1r0e5G?WnuWJGbkj3T2XoSML@v&eRuuY;R;-65FrajHgYPVgG*E z!&%GRW?c~5?N6XGwwDePanDpAeYW1ny(C-Ttmb|xvUL);vy40#jHZE=<7E3pWOKDi z|D+6{U6-{;^qdb9@CIbtRj+`%B1fQ!Evf1 zS<)f$fhPIp2f@2n;g`EiF}FixU3*IaP7M-vSGiiG??wf_>e!WNk=Kyji<8kPNFr4@ z8H|%CcAQ~ujobFxz+BoRqME5j`scX->RPHLxy4mO^=vvEIA8hWKF@{RYL6|LQ=^Du zrUL2bA#3DVGK0lfiW8x(dmihb-l};CTt`;$9KqOf}L+>PEsPk^0XT z;cx<%^XHb4TCqzi)dqLjQ(db}?a{C1+{m%ysl+RU|@#7>jlI$op46-;Zph-Ri5cxLsm-tN56|LQp$*~cn)?bW+?M+Z2p zbnR#F-hR)DAkn!m8Jgp0G*PpS;o?80(gPmsxJrg#@d#q+VNbneGu$ z&C~>ag|3lmNrmowk?Q4ARDfIbxPoVG7tzer2fd=wNV7yyIaj2aCE`3VqeCk!wla`42^|ovwGZsypl1mhvZHQ9;o*5y4DN(63;z zaDsnt2=33PZbxM93KmE!cxy#sG)ee9%~bw;wXTt0Nww~Ggx|reHyMwkUZT#jG}XGk z@!H0j>=9ATR0Dm!+(@+~Uw)fVjVpKR+aaf^Zj~?Vbvi3=0t>rDTr)Mo)$$YG|7LX7 z_5Vkmbz^egruBw)tB=du!Lk*V|51J18H8QENa}WH4cF;pK-rz3+Y$S<^g}WI{cG9B zq~5z7wRm)$=T^`zek`K(v`#a%L%&Wfj*-T^yz-D_o!Yh1D3cN_lAvdugf+rCo#)km z2k@t7t)Gr1(Jo{$u)*JVphH(JgWN`0$ogdPTa<;YLGMzh07PXmbqFmPgRW z<91YT$+Gsi#BypDvCLEr{an(Gaal5#^a^3wS}5D;OoKa@w2se~=Qi8+ZV}^51<|i0 z*T}dei#}x-4|~06ny53loO{4`7Hq66I`!B>Iq%+&gPCV?YV zcW);l_&0{&QMfE!qChKnYsFwRiTGtIe4gKh^ZRSVFW%6(9D!S9!r-mNFPcRBa#cOw zYXJb)#a~G#{42w6+GF7M-CUcRM7AQAh4It$TC6ZNJzrgGjKmU>-y$SWCUJkJ&fs!1 zZb!2A*d{r(iefTTx$`TnHIgh@Y3-LO$>Uz6o@8~KV(v<77en-x0;~-pcDY(zd4^lx zC3N(ux`cj#>|U5}ZAEd=kCL#r?Q|4AgjYAMN>tCUU-Z~uY}q9=pW-TZo@N-Vy6hOf zPuuoy{+!aR=8ae~np2NUG-q}Z%}mwKs~#A6>S&f^$Zu+zXVJK?R=`}I^#U&#j|s}e zDB_r@-kmDfEdH(rb+1n38+zdPy%YH}a^9v+L` z)42uQ8^C514|p;x+q#|0>PMJ4ANeK4w)Ed3YMEM{rxu4n!&~lRlTdq9k7X~MCCfoA zdP)MW{YbCXaH#D_j z91omdF&p$r*i5`Vq7C@k?YytvG2W)$5_U6-h+ePG!3V72%wuV5dL`=e5ggC+YSE}* zI#1lLq;b``+*^aMF^TwPs&igl#yDbeo=0B^zdtqnE{(d3uol&2V-oS}H91cF-RqfA zNyXu?;a5+tqyCU((Bu%<)MG0QXI2r(Oij*rS}r^izphCh4wH#`F7k7yDTXT&S%35C-}z&g5Ay} z*mrYjysZFO$S+fW^AULA{QfB8H;(%AUbHL`IQ6!WLu58l1ZFC4p5TQO{8~ovq!)~$ z(XtSndRrhkvxx|1s&KvsqLE-pMdF7U!S}*sJBoMU1TI%3xN}LUtT*$xfN^dVam>}_ z%CoU~UC#7bN-D#z7CCmB;TH7>jcYL(&TJxrx!RmpmLXEs)gvUz@((n@{eB$HTz^)B zt1O>Sy(J+yvxw+rDsz4v1%S7fUdcKNuVnPXLWz?&m?iOGe9!G%g1e4_qPXaF0cUHM zh-;=|cc$E1`B;Uhz50Fb=rD#n>}S8veRAHWexIcJxKhW&m(|DRit{1GeA|xqLl)P) zNk4*X$K@RP6>vapM(;ST4fxvae4^f=@5gYBURP1AcZir~YIlAmCma=xcHS-YR7`*0 z9^GN+e8vIaS+E(VPih0cc00G#yTvqmT?w_`BchtA=lMzoj!PZYl1j!wJ-)r(d^8`1 ziStpKUCA&W6PSrn!tn{Fs^|OS8#$Kr#eYw8d>1Bmbveu6KFx6+JtgSse~YMPYI%OP ziAHKA(f7MR?PhRmFuooo(C($q;4-}j@e`u?#9OHa-nyNe>eco*XSnb=h`K6HFf~0- zGLFh3^N8={<9cc7NX|SilAK#bF`29Fl{FDR_k__zARe`?U3^=UeBGD1i*-YJUt=x^_*H1TOOIE~tu{6e8svxJP zSwDN+X}Yr+RSezl0PN}3?F`gUHr>YaYQo8W5#>xJaJ4+2o2T4R4somP9pX3Z##;R@ zmopN$;$btCzpV}U+U9x52D+u<5tF zGh;bH@~XWe!kLPr@11TWTvA1OE+;&QqhubBgWhB`ayyDMd#5)8#c#puBHG1WBCeVG zqvv|zTt92L)@#TpuAzI{%uM(*Gw&PrCb|)q`sc_%D(*^pl~@nd4d;( z_40Mi_4<4oY>m}Emw9GBskIrT-V%&6i-=yX`slkt0KU3>TB4*sqv^eR+3V>nN#=aOu$(qS1W>4TIwG_6M*z3rwFPx?pNMRx{^wba{^`LNk>`zba)T)sp!-P=&xz?13cVG|kLaDKl@25G(iFJmd0T0uL=R literal 0 HcmV?d00001