#ifndef FCC_H
#define FCC_H 1

/*  Fortran C Converter header file for converted files

    this file describes the interface between C99 source text (converted from Fortran95) and supported libraries 
	for execute converted program */

// implemented LIBM functions
#include <math.h>

// defines for implemented in LIBM functions (generated file)
#include "config.h"

//  Fortran C Converter Support library hrader file

#ifdef __LCC__
#define ATTRIBUTE_MALLOC __attribute__((malloc))
#else
#define ATTRIBUTE_MALLOC 
#endif

// Generic helper definitions for shared library support
#if defined _WIN32 //|| defined __CYGWIN__
  #define FCC_HELPER_DLL_IMPORT __declspec(dllimport)
  #define FCC_HELPER_DLL_EXPORT __declspec(dllexport)
  #define FCC_HELPER_DLL_LOCAL
#else
  #if __GNUC__ >= 4
    #define FCC_HELPER_DLL_IMPORT __attribute__ ((visibility("default")))
    #define FCC_HELPER_DLL_EXPORT __attribute__ ((visibility("default")))
    #define FCC_HELPER_DLL_LOCAL  __attribute__ ((visibility("hidden")))
  #else
    #define FCC_HELPER_DLL_IMPORT
    #define FCC_HELPER_DLL_EXPORT
    #define FCC_HELPER_DLL_LOCAL
  #endif
#endif

#ifdef FCCS_DLL // defined if we are building the FCC DLL (instead of using it)
    #define FCC_API FCC_HELPER_DLL_EXPORT
#else
    #define FCC_API FCC_HELPER_DLL_IMPORT
#endif
#define FCC_LOCAL FCC_HELPER_DLL_LOCAL

#ifdef _MSC_VER
typedef long ssize_t;
#else
#include <sys/types.h>
#endif
//typedef ssize_t index_type;

/* types for values */
typedef char integer1;
typedef short int integer2;
typedef int integer4;
typedef long long integer8;
typedef unsigned char u_integer1;
typedef unsigned short u_integer2;
typedef unsigned u_integer4;
typedef unsigned long long u_integer8;

typedef char logical1;
typedef short int logical2;
typedef int logical4;
typedef long long logical8;

typedef float real4;
typedef double real8;
typedef long double real16;

#if HAVE_COMPLEX_H
#include <complex.h>
	typedef float complex complex4;
	typedef double complex complex8;
	typedef long double complex complex16;
#else
	typedef struct { real4 x, y; } complex4;
	#ifdef _COMPLEX_DEFINED
		#define complex8 struct _complex
	#else
		typedef struct { real8 x, y; } complex8;
	#endif
	typedef struct { real16 x, y; } complex16;
#endif

/* for multiple entry points */
union multitype_u 
{	
	integer1 i1;
	integer2 i2;
	integer4 i4;
	integer8 i8; 
	logical1 l1;
	logical2 l2;
	logical4 l4;
	logical8 l8; 
	real4 r4;
	real8 r8;
	real16 r16;
	complex4 c4;
	complex8 c8;
	complex16 c16;
};

typedef union multitype_u multitype_u;


/* some macros */

#define VOID void
#define TRUE_ (1)
#define FALSE_ (0)
#ifndef NULL
#define NULL ((void*)0)
#endif

#ifdef _MSC_VER
#define CCALL __cdecl
#pragma section(".CRT$XCU",read)
#define FCC_INITIALIZER(f) \
   static void __cdecl f(void); \
   __declspec(allocate(".CRT$XCU")) void (__cdecl*f##_)(void) = f; \
   static void __cdecl f(void)

#else
#define FCC_INITIALIZER(f) \
   static __attribute__ ((constructor)) void f(void)
#endif

/* Array implementation stuff */

/* NEW */
typedef ssize_t index_type;
/* The following two definitions must be consistent with the types used
   by the compiler.  */
/* The type used of array indices, amongst other things.  */
//typedef ptrdiff_t index_type;

/* The type used for the lengths of character variables.  */
typedef integer4 charlen_type;

/* Definitions of CHARACTER data types:
     - CHARACTER(KIND=1) corresponds to the C char type,
     - CHARACTER(KIND=4) corresponds to an unsigned 32-bit integer.  */

#ifdef _WIN32
typedef wchar_t char4;
#elif __LCC__
typedef int char4;
#elif __x86_64__
typedef int char4;
#else
typedef long int char4;
#endif

#define GFC_MAX_DIMENSIONS 7

typedef struct descriptor_dimension
{
  index_type _stride;
  index_type lower_bound;
  index_type _ubound;
} descriptor_dimension;

#define FCC_ARRAY_DESCRIPTOR(r, type) \
struct {\
  type *base_addr;\
  index_type offset;\
  index_type dtype;\
  descriptor_dimension dim[r];\
}
// in the old version "base_addr" called "data"


typedef FCC_ARRAY_DESCRIPTOR(1, index_type) shape_type;
typedef FCC_ARRAY_DESCRIPTOR(GFC_MAX_DIMENSIONS, char) fcc_parray;

/* Commonly used array descriptor types.  */
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void*) fcc_array_void;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char) fcc_array_char;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, char4) fcc_array_char4;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, integer1) fcc_array_i1;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, integer2) fcc_array_i2;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, integer4) fcc_array_i4;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, integer8) fcc_array_i8;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, real4) fcc_array_r4;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, real8) fcc_array_r8;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, real16) fcc_array_r16;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, complex4) fcc_array_c4;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, complex8) fcc_array_c8;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, complex16) fcc_array_c16;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, logical1) fcc_array_l1;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, logical2) fcc_array_l2;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, logical4) fcc_array_l4;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, logical8) fcc_array_l8;
typedef FCC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, void) array_t;

/* I/O stuff */

/* Basic types used in data transfers.  */

typedef enum
{
	BT_UNKNOWN = 0,
	BT_INTEGER,
	BT_LOGICAL,
	BT_REAL,
	BT_COMPLEX,
	BT_DERIVED,
	BT_CHARACTER,
	BT_CLASS,
	BT_PROCEDURE,
	BT_HOLLERITH,
	BT_VOID,
	BT_ASSUMED
} bt;

typedef enum
{
	READING, 
	WRITING
} unit_mode;

typedef enum
{ 
	BLANK_NULL, 
	BLANK_ZERO, 
	BLANK_UNSPECIFIED 
} unit_blank;

typedef enum
{ 
	ADVANCE_YES, 
	ADVANCE_NO, 
	ADVANCE_UNSPECIFIED 
} unit_advance;

typedef enum
{ SIGN_PROCDEFINED, SIGN_SUPPRESS, SIGN_PLUS, SIGN_UNSPECIFIED }
unit_sign;

typedef enum
{ SIGN_S, SIGN_SS, SIGN_SP }
unit_sign_s;

/* Define the type used for the current record number for large file I/O.
   The size must be consistent with the size defined on the compiler side.  */
typedef integer8 GFC_IO_INT;

#define CHARACTER_1(name) \
	char * name; \
	index_type name ## _len
#define CHARACTER_2(name) \
	index_type name ## _len; \
	char * name

typedef struct st_parameter_common
{
	integer4 flags;
	integer4 unit;
	const char *filename;
	integer4 line;
	CHARACTER_2 (iomsg);
	integer4 *iostat;
} st_parameter_common;

typedef struct st_parameter_open
{
	st_parameter_common common;
	integer4 recl_in;
	CHARACTER_2 (file);
	CHARACTER_1 (status);
	CHARACTER_2 (access);
	CHARACTER_1 (form);
	CHARACTER_2 (blank);
	CHARACTER_1 (position);
	CHARACTER_2 (action);
	CHARACTER_1 (delim);
	CHARACTER_2 (pad);
	CHARACTER_1 (convert);
	CHARACTER_2 (decimal);
	CHARACTER_1 (encoding);
	CHARACTER_2 (round);
	CHARACTER_1 (sign);
	CHARACTER_2 (asynchronous);
	integer4 *newunit;
} st_parameter_open;


typedef struct st_parameter_close
{
	st_parameter_common common;
	CHARACTER_1 (status);
} st_parameter_close;

typedef struct st_parameter_filepos
{
	st_parameter_common common;
} st_parameter_filepos;

typedef struct st_parameter_inquire
{
	st_parameter_common common;
	integer4 *exist, *opened, *number, *named;
	integer4 *nextrec, *recl_out;
	GFC_IO_INT *strm_pos_out;
	CHARACTER_1 (file);
	CHARACTER_2 (access);
	CHARACTER_1 (form);
	CHARACTER_2 (blank);
	CHARACTER_1 (position);
	CHARACTER_2 (action);
	CHARACTER_1 (delim);
	CHARACTER_2 (pad);
	CHARACTER_1 (name);
	CHARACTER_2 (sequential);
	CHARACTER_1 (direct);
	CHARACTER_2 (formatted);
	CHARACTER_1 (unformatted);
	CHARACTER_2 (read);
	CHARACTER_1 (write);
	CHARACTER_2 (readwrite);
	CHARACTER_1 (convert);
	integer4 flags2;
	CHARACTER_1 (asynchronous);
	CHARACTER_2 (decimal);
	CHARACTER_1 (encoding);
	CHARACTER_2 (round);
	CHARACTER_1 (sign);
	integer4 *pending;
	GFC_IO_INT *size;
	integer4 *id;
	CHARACTER_1 (iqstream);

} st_parameter_inquire;



typedef struct st_parameter_dt
{
	st_parameter_common common;
	GFC_IO_INT rec;
	integer4 *size, *iolength;
	fcc_array_char *internal_unit_desc;

	CHARACTER_1 (format);
	CHARACTER_2 (advance);
	CHARACTER_1 (internal_unit);
	CHARACTER_2 (namelist_name);
	/* Private part of the structure.  The compiler just needs
	to reserve enough space.  */
	union
	{
		struct
		{
			void (*transfer) (struct st_parameter_dt *, bt, void *, int,
				size_t, size_t);
			struct gfc_unit *current_unit;
			/* Item number in a formatted data transfer.  Also used in namelist
			read_logical as an index into line_buffer.  */
			int item_count;
			unit_mode mode;
			unit_blank blank_status;
			unit_sign sign_status;
			int scale_factor;
			int max_pos; /* Maximum righthand column written to.  */
			/* Number of skips + spaces to be done for T and X-editing.  */
			int skips;
			/* Number of spaces to be done for T and X-editing.  */
			int pending_spaces;
			/* Whether an EOR condition was encountered. Value is:
			0 if no EOR was encountered
			1 if an EOR was encountered due to a 1-byte marker (LF)
			2 if an EOR was encountered due to a 2-bytes marker (CRLF) */
			int sf_seen_eor;
			unit_advance advance_status;

			unsigned reversion_flag : 1; /* Format reversion has occurred.  */
			unsigned first_item : 1;
			unsigned seen_dollar : 1;
			unsigned eor_condition : 1;
			unsigned no_leading_blank : 1;
			unsigned char_flag : 1;
			unsigned input_complete : 1;
			unsigned at_eol : 1;
			unsigned comma_flag : 1;
			/* A namelist specific flag used in the list directed library
			to flag that calls are being made from namelist read (eg. to
			ignore comments or to treat '/' as a terminator)  */
			unsigned namelist_mode : 1;
			/* A namelist specific flag used in the list directed library
			to flag read errors and return, so that an attempt can be
			made to read a new object name.  */
			unsigned nml_read_error : 1;
			/* A sequential formatted read specific flag used to signal that a
			character string is being read so don't use commas to shorten a
			formatted field width.  */
			unsigned sf_read_comma : 1;
			/* A namelist specific flag used to enable reading input from 
			line_buffer for logical reads.  */
			unsigned line_buffer_enabled : 1;
			/* An internal unit specific flag used to identify that the associated
			unit is internal.  */
			unsigned unit_is_internal : 1;
			/* An internal unit specific flag to signify an EOF condition for list
			directed read.  */
			unsigned at_eof : 1;
			/* Used for g0 floating point output.  */
			unsigned g0_no_blanks : 1;
			/* Used to signal use of free_format_data.  */
			unsigned format_not_saved : 1;
		    /* A flag used to identify when a non-standard expanded namelist read
				 has occurred.  */
			unsigned expanded_read : 1;
			  /* 13 unused bits.  */

			char last_char;
			char nml_delim;

			int repeat_count;
			int saved_length;
			int saved_used;
			bt saved_type;
			char *saved_string;
			char *scratch;
			char *line_buffer;
			struct format_data *fmt;
//			void /* jmp_buf */ *eof_jump;
			struct namelist_type *ionml;
	       /* Current position within the look-ahead line buffer.  */
			int line_buffer_pos;
			//int expanded_read;
			/* Storage area for values except for strings.  Must be large
			enough to hold a complex value (two reals) of the largest
			kind.  */
			char value[32];
			GFC_IO_INT size_used;
		} p;
		/* This pad size must be equal to the pad_size declared in
		trans-io.c (gfc_build_io_library_fndecls).  The above structure
		must be smaller or equal to this array.  */
		char pad[16 * sizeof (char *) + 32 * sizeof (int)];
	} u;
	integer4 *id;
	GFC_IO_INT pos;
	CHARACTER_1 (asynchronous);
	CHARACTER_2 (blank);
	CHARACTER_1 (decimal);
	CHARACTER_2 (delim);
	CHARACTER_1 (pad);
	CHARACTER_2 (round);
	CHARACTER_1 (sign);
} st_parameter_dt;

/* NEW */
typedef struct
{
  st_parameter_common common;
  CHARACTER_1 (id);
}
st_parameter_wait;


/* I/O support functions */

FCC_API void _fcc_read_integer (st_parameter_dt*, void*, int);
FCC_API void _fcc_read_real (st_parameter_dt*, void*, int);
FCC_API void _fcc_read_logical (st_parameter_dt*, void*, int);
FCC_API void _fcc_read_character (st_parameter_dt*, void*, int);
FCC_API void _fcc_read_complex (st_parameter_dt*, void*, int);

FCC_API void _fcc_write_integer (st_parameter_dt*, const void*, int);
FCC_API void _fcc_write_real (st_parameter_dt*, const void*, int);
FCC_API void _fcc_write_logical (st_parameter_dt*, const void*, int);
FCC_API void _fcc_write_character (st_parameter_dt*, const void*, int);
FCC_API void _fcc_write_complex (st_parameter_dt*, const void*, int);

FCC_API void _fcc_st_iolength (st_parameter_dt*);
FCC_API void _fcc_st_iolength_done (st_parameter_dt*);
FCC_API void _fcc_st_read (st_parameter_dt*);
FCC_API void _fcc_st_read_done (st_parameter_dt*);
FCC_API void _fcc_st_write (st_parameter_dt*);
FCC_API void _fcc_st_write_done (st_parameter_dt*);
FCC_API void _fcc_st_set_nml_var (st_parameter_dt*, void*, char*, integer4, charlen_type, integer4);
FCC_API void _fcc_st_set_nml_var_dim (st_parameter_dt *dtp, integer4 n_dim,
									  index_type stride, index_type lbound, index_type ubound);
FCC_API void _fcc_st_open (st_parameter_open*);
FCC_API void _fcc_st_close (st_parameter_close*);
FCC_API void _fcc_st_backspace (st_parameter_filepos*);
FCC_API void _fcc_st_endfile (st_parameter_filepos*);
FCC_API void _fcc_st_rewind (st_parameter_filepos*);
FCC_API void _fcc_st_flush (st_parameter_filepos*);
FCC_API void _fcc_st_inquire (st_parameter_inquire*);

// NEW:
FCC_API void _fcc_transfer_integer (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_integer_write (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_real (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_real_write (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_logical (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_logical_write (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_character (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_character_write (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_character_wide (st_parameter_dt *, void *, int, int);
FCC_API void _fcc_transfer_character_wide_write (st_parameter_dt *, void *, int, int);
FCC_API void _fcc_transfer_complex (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_complex_write (st_parameter_dt *, void *, int);
FCC_API void _fcc_transfer_array (st_parameter_dt *, fcc_array_char *, int,  charlen_type);
FCC_API void _fcc_transfer_array_write (st_parameter_dt *, fcc_array_char *, int, charlen_type);
FCC_API void _fcc_st_wait (st_parameter_wait *);

/* intrinsic */

FCC_API charlen_type _fcc_fstrcpy (char*, charlen_type, const char *, charlen_type);
FCC_API charlen_type _fcc_fstrcpy_char4 (char4*, charlen_type, const char4 *, charlen_type);
FCC_API void _fcc_fstrmove (char*, charlen_type, const char *, charlen_type);
FCC_API void _fcc_fstrmove_char4 (char4*, charlen_type, const char4 *, charlen_type);
FCC_API int _fcc_strlen (const char*);
FCC_API int _fcc_compare_string (charlen_type, const char *, charlen_type, const char *);
FCC_API void _fcc_concat_string (charlen_type, char*, charlen_type, const char*, charlen_type, const char*);
FCC_API void _fcc_concat_string_char4 (charlen_type, char4*, charlen_type, const char4*, charlen_type, const char4*);
FCC_API charlen_type _fcc_string_len_trim (charlen_type, const char*);
FCC_API void _fcc_adjustl (char*, charlen_type, const char*);
FCC_API void _fcc_adjustl_char4 (char4*, charlen_type, const char4*);
FCC_API void _fcc_adjustr (char*, charlen_type, const char*);
FCC_API void _fcc_adjustr_char4 (char4*, charlen_type, const char4*);
FCC_API charlen_type _fcc_string_index (charlen_type, const char*, charlen_type, const char*, logical4);
FCC_API charlen_type _fcc_string_index_char4 (charlen_type, const char4*, charlen_type, const char4*, logical4);
FCC_API charlen_type _fcc_string_scan (charlen_type, const char*, charlen_type, const char*, logical4);
FCC_API charlen_type _fcc_string_scan_char4 (charlen_type, const char4*, charlen_type, const char4*, logical4);
FCC_API charlen_type _fcc_string_verify (charlen_type, const char*, charlen_type, const char*, logical4);
FCC_API charlen_type _fcc_string_verify_char4 (charlen_type, const char4*, charlen_type, const char4*, logical4);
/* NEW */
FCC_API void _fcc_string_minmax (charlen_type*, char **, int, int, ...);
FCC_API void _fcc_string_minmax_char4 (charlen_type*, char4 **, int, int, ...);
/* */
FCC_API void _fcc_convert_char1_to_char4 (char4 **dst, charlen_type len, const char *src);
FCC_API void _fcc_convert_char4_to_char1 (char **dst, charlen_type len,	const char4 *src);
FCC_API void _fcc_string_trim (charlen_type*, char **, charlen_type, const char*);
FCC_API void _fcc_string_trim_char4 (charlen_type*, char4 **, charlen_type, const char4*);
FCC_API void _fcc_string_repeat (char*, charlen_type, const char*, integer4);
FCC_API void _fcc_string_repeat4 (char4*, charlen_type, const char4*, integer4);
FCC_API void _fcc_random_seed_i4 (integer4 *size, fcc_array_i4 *put, fcc_array_i4 *get);
FCC_API void _fcc_random_seed_i8 (integer8 *size, fcc_array_i8 *put, fcc_array_i8 *get);
FCC_API void _fcc_random_r4 (real4*);
FCC_API void _fcc_random_r8 (real8*);
FCC_API void _fcc_arandom_r4 (fcc_array_r4*);
FCC_API void _fcc_arandom_r8 (fcc_array_r8*);
FCC_API void _fcc_random_r16 (real16*);
FCC_API void _fcc_arandom_r16 (fcc_array_r16*);
FCC_API void _fcc_cshift0_1(fcc_array_char *ret, const fcc_array_char *array, const integer1 *pshift, const integer1 *pdim);
FCC_API void _fcc_cshift0_2(fcc_array_char *ret, const fcc_array_char *array, const integer2 *pshift, const integer2 *pdim);
FCC_API void _fcc_cshift0_4(fcc_array_char *ret, const fcc_array_char *array, const integer4 *pshift, const integer4 *pdim);    
FCC_API void _fcc_cshift0_8(fcc_array_char *ret, const fcc_array_char *array, const integer8 *pshift, const integer8 *pdim);    
FCC_API void _fcc_cshift0_1_char(fcc_array_char *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char *array,
				const integer1 *pshift, const integer1 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_2_char(fcc_array_char *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char *array,
				const integer2 *pshift, const integer2 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_4_char(fcc_array_char *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char *array,
				const integer4 *pshift, const integer4 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_8_char(fcc_array_char *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char *array,
				const integer8 *pshift, const integer8 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_1_char4(fcc_array_char4 *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char4 *array,
				const integer1 *pshift, const integer1 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_2_char4(fcc_array_char4 *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char4 *array,
				const integer2 *pshift, const integer2 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_4_char4(fcc_array_char4 *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char4 *array,
				const integer4 *pshift, const integer4 *pdim, integer4 array_length);
FCC_API void _fcc_cshift0_8_char4(fcc_array_char4 *ret, integer4 ret_length __attribute__((unused)), const fcc_array_char4 *array,
				const integer8 *pshift, const integer8 *pdim, integer4 array_length);

/* NEW */
FCC_API int _fcc_compare_string_char4 (charlen_type, const char4 *, charlen_type, const char4 *); 
FCC_API charlen_type _fcc_string_len_trim_char4 (charlen_type, const char4 *); 
FCC_API int _fcc_access_func (char *, char *, charlen_type, charlen_type);
FCC_API integer4 _fcc_iargc (void);
FCC_API void _fcc_get_command_argument_i4 (integer4*, char*, integer4 *, integer4 *, charlen_type);
FCC_API void _fcc_get_command_argument_i8 (integer8 *, char *, integer8 *, integer8 *, charlen_type);
FCC_API void _fcc_get_command_i4 (char *, integer4 *, integer4 *,  charlen_type);
FCC_API void _fcc_get_command_i8 (char *, integer8 *, integer8 *, charlen_type);
FCC_API void _fcc_chdir_i4_sub (char *, integer4 *, charlen_type);
FCC_API void _fcc_chdir_i8_sub (char *, integer8 *, charlen_type);
FCC_API integer4 _fcc_chdir_i4 (char *, charlen_type);
FCC_API integer8 _fcc_chdir_i8 (char *, charlen_type);
FCC_API int _fcc_chmod_func (char *, char *, charlen_type, charlen_type);
FCC_API void _fcc_chmod_i4_sub (char *, char *, integer4 *, charlen_type, charlen_type);
FCC_API void _fcc_chmod_i8_sub (char *, char *, integer8 *, charlen_type, charlen_type);
FCC_API integer4 _fcc_mclock (void);
FCC_API integer8 _fcc_mclock8 (void);
FCC_API void _fcc_getenv(char *, char *, charlen_type, charlen_type);
FCC_API void _fcc_get_environment_variable_i4 (char *, char *, integer4 *, integer4 *, 
			   logical4 *, charlen_type, charlen_type);
FCC_API void _fcc_get_environment_variable_i8 (char *, char *, integer8 *, integer8 *,
						   logical8 *, charlen_type, charlen_type);
FCC_API void _fcc_bessel_jn_r4 (fcc_array_r4 * const restrict ret, int n1, int n2, real4 x);
FCC_API void _fcc_bessel_yn_r4 (fcc_array_r4 * const restrict ret, int n1, int n2, real4 x);
FCC_API void _fcc_bessel_jn_r8 (fcc_array_r8 * const restrict ret, int n1, int n2, real8 x);
FCC_API void _fcc_bessel_yn_r8 (fcc_array_r8 * const restrict ret, int n1, int n2, real8 x);
FCC_API void _fcc_bessel_jn_r16 (fcc_array_r16 * const restrict ret, int n1, int n2, real16 x);
FCC_API void _fcc_bessel_yn_r16 (fcc_array_r16 * const restrict ret, int n1, int n2, real16 x);
FCC_API void _fcc_iall_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miall_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict array, 
	const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_siall_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict, 
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iall_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miall_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siall_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iall_i4 (fcc_array_i4 * const restrict, 
	fcc_array_i4 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miall_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
					   const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siall_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iall_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miall_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict, 
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siall_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iany_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miany_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict, 
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siany_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iany_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miany_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siany_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iany_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miany_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siany_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iany_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miany_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict,
							const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siany_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict,
							const index_type * const restrict, logical4 *);
FCC_API void _fcc_iparity_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miparity_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict,
							   const index_type * const restrict, 	fcc_array_l1 * const restrict);
FCC_API void _fcc_siparity_i1 (fcc_array_i1 * const restrict, fcc_array_i1 * const restrict,
							   const index_type * const restrict, logical4 *);
FCC_API void _fcc_iparity_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miparity_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							   const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siparity_i2 (fcc_array_i2 * const restrict, fcc_array_i2 * const restrict,
							   const index_type * const restrict, logical4 *);
FCC_API void _fcc_iparity_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miparity_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
							   const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siparity_i4 (fcc_array_i4 * const restrict, fcc_array_i4 * const restrict,
							   const index_type * const restrict, logical4 *);
FCC_API void _fcc_iparity_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict, const index_type * const restrict);
FCC_API void _fcc_miparity_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict,
							   const index_type * const restrict, fcc_array_l1 * const restrict);
FCC_API void _fcc_siparity_i8 (fcc_array_i8 * const restrict, fcc_array_i8 * const restrict,
							   const index_type * const restrict, logical4 *);

/* special run time support */

FCC_API void * _fcc_xmalloc (size_t n);
FCC_API void * _fcc_xcalloc (size_t nmemb, size_t size);
FCC_API void _fcc_set_args (int, char **); //
FCC_API void _fcc_internal_free (void *);
FCC_API void _fcc_stop_numeric (integer4) __attribute__((noreturn));
FCC_API void _fcc_stop_numeric_f08 (integer4) __attribute__((noreturn));
FCC_API void _fcc_stop_string (const char *string, charlen_type) __attribute__((noreturn));
FCC_API void _fcc_error_stop_string (const char *, charlen_type) __attribute__((noreturn));
FCC_API void _fcc_error_stop_numeric (integer4) __attribute__((noreturn));
FCC_API void *_fcc_realloc (void *mem, index_type size) ATTRIBUTE_MALLOC;
FCC_API void* _fcc_allocate(void *mem, index_type size, integer4 * stat, char* errmsg, integer4 len_errmsg) ATTRIBUTE_MALLOC;
FCC_API void _fcc_deallocate (void*, integer4*, char*, integer4);
FCC_API void _fcc_set_convert (integer4);
FCC_API void _fcc_set_record_marker (integer4);
FCC_API void _fcc_set_options (int num, int options[]);
FCC_API void _fcc_set_max_subrecord_length(int val); //NEW
FCC_API void* _fcc_internal_pack (fcc_array_char*);
FCC_API void _fcc_internal_unpack (fcc_array_char*, const void *);
FCC_API void _fcc_pause_numeric (integer4);
FCC_API void _fcc_pause_string (char *string, charlen_type len);
FCC_API void _fcc_getarg_i4 (integer4 *pos, char  *val, charlen_type val_len);
FCC_API void _fcc_getarg_i8 (integer8 *pos, char  *val, charlen_type val_len);

FCC_API void _fcc_backtrace (void); //NEW
FCC_API void _fcc_os_error (const char *); //NEW
FCC_API void _fcc_runtime_error_at (const char *, const char *, ...); //NEW
FCC_API void _fcc_runtime_warning_at (const char *, const char *, ...); //NEW
FCC_API void _fcc_generate_error (st_parameter_common *, int, const char *); //NEW
FCC_API index_type _fcc_size0 (const array_t * array); //NEW
FCC_API void _fcc_store_exe_path (const char *); //NEW
FCC_API void _fcc_set_max_subrecord_length(int val); //NEW

typedef struct select_struct
{
  char *low;
  int low_len;
  char *high;
  int high_len;
  int  address;
} select_struct;

typedef struct select_struct_char4
{
  char4 *low;
  int low_len;
  char4 *high;
  int high_len;
  int  address;
} select_struct_char4;

FCC_API int _fcc_select_string (select_struct *table, int table_len, const char *selector, int selector_len);
FCC_API int _fcc_select_string_char4 (select_struct_char4 *table, int table_len, const char4 *selector, int selector_len);
FCC_API void _fcc_abort(void) __attribute__((noreturn));
FCC_API void _fcc_exit_i4 (integer4 * status) __attribute__((noreturn));
FCC_API void _fcc_exit_i8 (integer8 * status) __attribute__((noreturn));
FCC_API void _fcc_cpu_time_4 (real4 *time);
FCC_API void _fcc_cpu_time_8 (real8 *time);
FCC_API void _fcc_cpu_time_16 (real16 *time);
FCC_API void _fcc_second_sub (real4 *s);
FCC_API real4 _fcc_second (void);
FCC_API void _fcc_system_clock_1(integer1 *count, integer1 *count_rate, integer1 *count_max); //? missing
FCC_API void _fcc_system_clock_2(integer2 *count, integer2 *count_rate, integer2 *count_max); //? missing
FCC_API void _fcc_system_clock_4(integer4 *count, integer4 *count_rate, integer4 *count_max);
FCC_API void _fcc_system_clock_8 (integer8 *count, integer8 *count_rate, integer8 *count_max);
FCC_API void _fcc_date_and_time (char *__date, char *__time, char *__zone, fcc_array_i4 *__values, integer4 __date_len,
	       integer4 __time_len, integer4 __zone_len);
FCC_API real4 _fcc_secnds (real4 *x);
FCC_API void _fcc_itime_i4 (fcc_array_i4 *__values);
FCC_API void _fcc_itime_i8 (fcc_array_i8 *__values);
FCC_API void _fcc_idate_i4 (fcc_array_i4 *__values);
FCC_API void _fcc_idate_i8 (fcc_array_i8 *__values);
FCC_API void _fcc_gmtime_i4 (integer4 * t, fcc_array_i4 * tarray);
FCC_API void _fcc_gmtime_i8 (integer8 * t, fcc_array_i8 * tarray);
FCC_API void _fcc_ltime_i4 (integer4 * t, fcc_array_i4 * tarray);
FCC_API void _fcc_ltime_i8 (integer8 * t, fcc_array_i8 * tarray);
FCC_API int _fcc_selected_int_kind (const int *r);						
FCC_API int _fcc_selected_real_kind (const int *p, const int *r, const int *rdx);		
FCC_API real4 _fcc_rrspacing_r4 (real4 s, int p);
FCC_API real8 _fcc_rrspacing_r8 (real8 s, int p);
FCC_API real16 _fcc_rrspacing_r16 (real16 s, int p);
FCC_API real4 _fcc_spacing_r4 (real4 s, int p, int emin, real4 tiny);
FCC_API real8 _fcc_spacing_r8 (real8 s, int p, int emin, real8 tiny);
FCC_API real16 _fcc_spacing_r16 (real16 s, int p, int emin, real16 tiny);
FCC_API real16 _fcc_set_exponent_r16 (real16 s, integer4 i);
FCC_API real4 _fcc_set_exponent_r4 (real4 s, integer4 i);
FCC_API real8 _fcc_set_exponent_r8 (real8 s, integer4 i);
FCC_API integer4 _fcc_exponent_r16 (real16 s);
FCC_API integer4 _fcc_exponent_r4 (real4 s);
FCC_API integer4 _fcc_exponent_r8 (real8 s);
FCC_API real16 _fcc_fraction_r16 (real16 s);
FCC_API real4 _fcc_fraction_r4 (real4 s);
FCC_API real8 _fcc_fraction_r8 (real8 s);
FCC_API real16 _fcc_nearest_r16 (real16 s, real16 dir);
FCC_API real4 _fcc_nearest_r4 (real4 s, real4 dir);
FCC_API real8 _fcc_nearest_r8 (real8 s, real8 dir);
FCC_API void _fcc_mvbits_i1(const integer1 *, const int *, const int *, integer1 *, const int *);
FCC_API void _fcc_mvbits_i2(const integer2 *, const int *, const int *, integer2 *, const int *);
FCC_API void _fcc_mvbits_i4(const integer4 *, const int *, const int *, integer4 *, const int *);
FCC_API void _fcc_mvbits_i8(const integer8 *, const int *, const int *, integer8 *, const int *);
FCC_API integer4 _fcc_ishftc4 (integer4 i, integer4 shift, integer4 size);
FCC_API integer8 _fcc_ishftc8 (integer8 i, integer4 shift, integer4 size);

/* NEW */
FCC_API void _fcc_dtime_sub(fcc_array_r4 *, real4 *);
FCC_API real4 _fcc_dtime (fcc_array_r4 *t);
FCC_API real4 _fcc_erfc_scaled_r4 (real4 x);
FCC_API real8 _fcc_erfc_scaled_r8 (real8 x);
FCC_API real16 _fcc_erfc_scaled_r16 (real16 x);
FCC_API void _fcc_etime_sub (fcc_array_r4 *t, real4 *result);
FCC_API real4 _fcc_etime (fcc_array_r4 *t);
FCC_API void _fcc_execute_command_line_i4 (const char *, logical4 *, integer4 *, integer4 *,
			 char *, charlen_type, charlen_type);
FCC_API void _fcc_execute_command_line_i8 (const char *, logical8 *, integer8 *, integer8 *,
			 char *, charlen_type, charlen_type);
typedef struct vtype
{
  integer4 hash;
  integer4 size;
  struct vtype *extends;
}
vtype;
FCC_API logical4 _fcc_is_extension_of (struct vtype *, struct vtype *);
FCC_API integer4 _fcc_fnum_i4 (integer4 *);
FCC_API integer8 _fcc_fnum_i8 (integer8 *);
FCC_API void _fcc_gerror (char *, charlen_type);
FCC_API void _fcc_getcwd_i4_sub (char *, integer4 *, charlen_type);
FCC_API void _fcc_getcwd_i8_sub (char *, integer8 *, charlen_type);
FCC_API integer4 _fcc_getcwd (char *, charlen_type);
FCC_API void _fcc_getlog (char * , charlen_type);
FCC_API integer4 _fcc_getgid (void);
FCC_API integer4 _fcc_getpid (void);
FCC_API integer4 _fcc_getuid (void);
FCC_API void _fcc_hostnm_i4_sub (char *, integer4 *, charlen_type);
FCC_API void _fcc_hostnm_i8_sub (char *, integer8 *, charlen_type);
FCC_API integer4 _fcc_hostnm (char *, charlen_type);
FCC_API integer4 _fcc_ierrno_i4 (void);
FCC_API integer8 _fcc_ierrno_i8 (void);
FCC_API void _fcc_kill_i4_sub (integer4 *, integer4 *, integer4 *);
FCC_API void _fcc_kill_i8_sub (integer8 *, integer8 *, integer8 *);
FCC_API integer4 _fcc_kill_i4 (integer4 *, integer4 *);
FCC_API integer8 _fcc_kill_i8 (integer8 *, integer8 *);
FCC_API void _fcc_link_i4_sub (char *, char *, integer4 *, charlen_type, charlen_type);
FCC_API void _fcc_link_i8_sub (char *, char *, integer8 *, charlen_type, charlen_type);
FCC_API integer4 _fcc_link_i4 (char *, char *, charlen_type, charlen_type);
FCC_API integer8 _fcc_link_i8 (char *, char *, charlen_type, charlen_type);
FCC_API void _fcc_free (void ** );
FCC_API void * _fcc_malloc (size_t * );
FCC_API void _fcc_move_alloc (fcc_array_char *, fcc_array_char *);
FCC_API void _fcc_move_alloc_c (fcc_array_char *, integer4 from_length __attribute__((unused)),
	      fcc_array_char *, integer4 to_length __attribute__((unused)));
FCC_API void _fcc_mvbits_i1 (const integer1 *, const int *, const int *, integer1 *, const int *);
FCC_API void _fcc_mvbits_i2 (const integer2 *, const int *, const int *, integer2 *, const int *);
FCC_API void _fcc_mvbits_i4 (const integer4 *, const int *, const int *, integer4 *, const int *);
FCC_API void _fcc_mvbits_i8 (const integer8 *, const int *, const int *, integer8 *, const int *);
FCC_API void _fcc_perror_sub (char *, charlen_type);
FCC_API void _fcc_srand (integer4 *i);
FCC_API integer4 _fcc_irand (integer4 *);
FCC_API real4 _fcc_rand (integer4 *i);
FCC_API void _fcc_rename_i4_sub (char *, char *, integer4 *, charlen_type, charlen_type);
FCC_API void _fcc_rename_i8_sub (char *, char *, integer8 *, charlen_type, charlen_type);
FCC_API integer4 _fcc_rename_i4 (char *, char *, charlen_type, charlen_type);
FCC_API integer8 _fcc_rename_i8 (char *, char *, charlen_type, charlen_type);
FCC_API integer4 _fcc_selected_char_kind (charlen_type, char *);
FCC_API void _fcc_signal_sub (int *, void (*)(int), int *);
FCC_API void _fcc_signal_sub_int (int *, int *, int *);
FCC_API int _fcc_signal_func (int *, void (*)(int));
FCC_API int _fcc_signal_func_int (int *, int *);

FCC_API void _fcc_alarm_sub_i4 (int *, void (*)(int), integer4 *);
FCC_API void _fcc_alarm_sub_i8 (int *, void (*)(int), integer8 *);
FCC_API void _fcc_alarm_sub_int_i4 (int *, int *, integer4 *);
FCC_API void _fcc_alarm_sub_int_i8 (int *, int *, integer8 *);

FCC_API void _fcc_sleep_i4_sub (integer4 *);
FCC_API void _fcc_sleep_i8_sub (integer8 *);
FCC_API void _fcc_stat_i4_sub (char *, fcc_array_i4 *, integer4 *, charlen_type);
FCC_API void _fcc_lstat_i4_sub (char *, fcc_array_i4 *, integer4 *, charlen_type);
FCC_API void _fcc_stat_i8_sub (char *, fcc_array_i8 *, integer8 *, charlen_type);
FCC_API void _fcc_lstat_i8_sub (char *, fcc_array_i8 *, integer8 *, charlen_type);
FCC_API integer4 _fcc_stat_i4 (char *, fcc_array_i4 *, charlen_type);
FCC_API integer8 _fcc_stat_i8 (char *, fcc_array_i8 *, charlen_type);
FCC_API integer4 _fcc_lstat_i4 (char *, fcc_array_i4 *, charlen_type);
FCC_API integer8 _fcc_lstat_i8 (char *, fcc_array_i8 *, charlen_type);
FCC_API void _fcc_fstat_i4_sub (integer4 *, fcc_array_i4 *, integer4 *);
FCC_API void _fcc_fstat_i8_sub (integer8 *, fcc_array_i8 *, integer8 *);
FCC_API integer4 _fcc_fstat_i4 (integer4 *, fcc_array_i4 *);
FCC_API integer8 _fcc_fstat_i8 (integer8 *, fcc_array_i8 *);
FCC_API void _fcc_symlnk_i4_sub (char *, char *, integer4 *, charlen_type, charlen_type);
FCC_API void _fcc_symlnk_i8_sub (char *, char *, integer8 *, charlen_type, charlen_type);
FCC_API integer4 _fcc_symlnk_i4 (char *, char *, charlen_type, charlen_type);
FCC_API integer8 _fcc_symlnk_i8 (char *, char *, charlen_type, charlen_type);
FCC_API void _fcc_system_sub (const char *fcmd, integer4 * status, charlen_type cmd_len);
FCC_API integer4 _fcc_system (const char *, charlen_type);
FCC_API integer4 _fcc_time_func (void);
FCC_API integer8 _fcc_time8_func (void);
FCC_API void _fcc_umask_i4_sub (integer4 *, integer4 *);
FCC_API void _fcc_umask_i8_sub (integer8 *, integer8 *);
FCC_API integer4 _fcc_umask_i4 (integer4 *);
FCC_API integer8 _fcc_umask_i8 (integer8 *);
FCC_API void _fcc_unlink_i4_sub (char *name, integer4 *status, charlen_type name_len);
FCC_API void _fcc_unlink_i8_sub (char *name, integer8 *status,  charlen_type name_len);
FCC_API integer4 _fcc_unlink (char *, charlen_type );
FCC_API void _fcc_norm2_r4 (fcc_array_r4 * const restrict, fcc_array_r4 * const restrict, const index_type * const restrict);
FCC_API void _fcc_norm2_r8 (fcc_array_r8 * const restrict, fcc_array_r8 * const restrict, const index_type * const restrict);
FCC_API void _fcc_norm2_r16 (fcc_array_r16 * const restrict, fcc_array_r16 * const restrict, const index_type * const restrict);
FCC_API void _fcc_parity_l1 (fcc_array_l1 * const restrict, fcc_array_l1 * const restrict, const index_type * const restrict);
FCC_API void _fcc_parity_l2 (fcc_array_l2 * const restrict, fcc_array_l2 * const restrict, const index_type * const restrict);
FCC_API void _fcc_parity_l4 (fcc_array_l4 * const restrict, fcc_array_l4 * const restrict, const index_type * const restrict);
FCC_API void _fcc_parity_l8 (fcc_array_l8 * const restrict, fcc_array_l8 * const restrict, const index_type * const restrict);


FCC_API void _fcc_all_l1 (fcc_array_l1 * const restrict retarray, fcc_array_l1 * const restrict array, 
			      const index_type * const restrict pdim);
FCC_API void _fcc_all_l2 (fcc_array_l2 * const restrict retarray, fcc_array_l1 * const restrict array, 
			      const index_type * const restrict pdim);
FCC_API void _fcc_all_l4 (fcc_array_l4 * const restrict retarray, fcc_array_l1 * const restrict array, 
			 const index_type * const restrict pdim);
FCC_API void _fcc_all_l8 (fcc_array_l8 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_any_l1 (fcc_array_l1 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_any_l2 (fcc_array_l2 * const restrict retarray, fcc_array_l1 * const restrict array, 
	              const index_type * const restrict pdim);
FCC_API void _fcc_any_l4 (fcc_array_l4 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_any_l8 (fcc_array_l8 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_count_1_l (fcc_array_i1 * const restrict, fcc_array_l1 * const restrict,
				  const index_type * const restrict);
FCC_API void _fcc_count_2_l (fcc_array_i2 * const restrict, fcc_array_l1 * const restrict,
				  const index_type * const restrict);
FCC_API void _fcc_count_4_l (fcc_array_i4 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_count_8_l (fcc_array_i8 * const restrict retarray, fcc_array_l1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_matmul_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict a, 
					  fcc_array_c16 * const restrict b);
FCC_API void _fcc_matmul_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict a, 
					 fcc_array_c4 * const restrict b);
FCC_API void _fcc_matmul_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict a, 
					 fcc_array_c8 * const restrict b);
FCC_API void _fcc_matmul_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict a, 
					 fcc_array_i1 * const restrict b);
FCC_API void _fcc_matmul_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict a, 
					 fcc_array_i2 * const restrict b);
FCC_API void _fcc_matmul_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict a, 
					 fcc_array_i4 * const restrict b);
FCC_API void _fcc_matmul_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict a, 
					 fcc_array_i8 * const restrict b);
FCC_API void _fcc_matmul_l4 (fcc_array_l4 * const restrict retarray, fcc_array_l1 * const restrict a, 
					 fcc_array_l1 * const restrict b);
FCC_API void _fcc_matmul_l8 (fcc_array_l8 * const restrict retarray, fcc_array_l1 * const restrict a, 
					 fcc_array_l1 * const restrict b);
FCC_API void _fcc_matmul_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict a, 
					  fcc_array_r16 * const restrict b);
FCC_API void _fcc_matmul_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict a, 
					 fcc_array_r4 * const restrict b);
FCC_API void _fcc_matmul_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict a, 
					 fcc_array_r8 * const restrict b);
//FCC_API void _fcc_matmul_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict a, 
//							 fcc_array_r8 * const restrict b, int try_blas, int blas_limit, blas_call gemm);
FCC_API void _fcc_maxval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_maxval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_maxval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_maxval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_maxval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_maxval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_maxval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_mmaxval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mmaxval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_smaxval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_minval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_minval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
				const index_type * const restrict pdim);
FCC_API void _fcc_minval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_minval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_minval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_minval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					 const index_type * const restrict pdim);
FCC_API void _fcc_mminval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mminval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					  const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminval_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sminval_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_product_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_product_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
				 const index_type * const restrict pdim);
FCC_API void _fcc_product_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_product_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_product_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_product_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_product_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim);
FCC_API void _fcc_product_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					   const index_type * const restrict pdim);
FCC_API void _fcc_product_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
				 const index_type * const restrict pdim);
FCC_API void _fcc_product_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
				 const index_type * const restrict pdim);
FCC_API void _fcc_mproduct_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_mproduct_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
						const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sproduct_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sproduct_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
						const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_sum_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
			  const index_type * const restrict pdim);
FCC_API void _fcc_sum_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
			 const index_type * const restrict pdim);
FCC_API void _fcc_sum_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
				   const index_type * const restrict pdim);
FCC_API void _fcc_sum_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_sum_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
				  const index_type * const restrict pdim);
FCC_API void _fcc_msum_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_c16 (fcc_array_c16 * const restrict retarray, fcc_array_c16 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_c4 (fcc_array_c4 * const restrict retarray, fcc_array_c4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_c8 (fcc_array_c8 * const restrict retarray, fcc_array_c8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_i1 (fcc_array_i1 * const restrict retarray, fcc_array_i1 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_i2 (fcc_array_i2 * const restrict retarray, fcc_array_i2 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_r16 (fcc_array_r16 * const restrict retarray, fcc_array_r16 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_r4 (fcc_array_r4 * const restrict retarray, fcc_array_r4 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_msum_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_ssum_r8 (fcc_array_r8 * const restrict retarray, fcc_array_r8 * const restrict array, 
					  const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_transpose_char (fcc_array_char *ret, 	integer4 ret_length, 
		fcc_array_char *source, integer4 source_length);
FCC_API void _fcc_transpose_char4 (fcc_array_char4 *ret, 	integer4 ret_length, 
		fcc_array_char4 *source, integer4 source_length);
FCC_API void _fcc_transpose (fcc_array_char *ret, fcc_array_char *source);
FCC_API void _fcc_transpose_c16 (fcc_array_c16 * const restrict ret, fcc_array_c16 * const restrict source);
FCC_API void _fcc_transpose_c4 (fcc_array_c4 * const restrict ret, fcc_array_c4 * const restrict source);
FCC_API void _fcc_transpose_c8 (fcc_array_c8 * const restrict ret, fcc_array_c8 * const restrict source);
FCC_API void _fcc_transpose_i4 (fcc_array_i4 * const restrict ret, fcc_array_i4 * const restrict source);
FCC_API void _fcc_transpose_i8 (fcc_array_i8 * const restrict ret, fcc_array_i8 * const restrict source);
FCC_API void _fcc_transpose_r16 (fcc_array_r16 * const restrict ret, fcc_array_r16 * const restrict source);
FCC_API void _fcc_transpose_r4 (fcc_array_r4 * const restrict ret, 	fcc_array_r4 * const restrict source);
FCC_API void _fcc_transpose_r8 (fcc_array_r8 * const restrict ret, fcc_array_r8 * const restrict source);
FCC_API void _fcc_spread (fcc_array_char *ret, const fcc_array_char *source, const index_type *along, const index_type *pncopies);
FCC_API void _fcc_spread_scalar (fcc_array_char *ret, const char *source, const index_type *along, const index_type *pncopies);
FCC_API void _fcc_spread_char (fcc_array_char *ret, integer4 ret_length, const fcc_array_char *source, const index_type *along,
	     const index_type *pncopies, integer4 source_length);
FCC_API void _fcc_spread_char4 (fcc_array_char4 *ret, integer4 ret_length, const fcc_array_char4 *source, const index_type *along,
	     const index_type *pncopies, integer4 source_length);
FCC_API void _fcc_spread_char_scalar (fcc_array_char *ret, integer4 ret_length,
		    const char *source, const index_type *along, const index_type *pncopies, integer4 source_length);
FCC_API void _fcc_cshift1_4 (fcc_array_char * const restrict ret, const fcc_array_char * const restrict array,
	const fcc_array_i4 * const restrict h, 	const integer4 * const restrict pwhich);
FCC_API void _fcc_cshift1_4_char (fcc_array_char * const restrict ret, 	integer4 ret_length, const fcc_array_char * const restrict array,
	const fcc_array_i4 * const restrict h, 	const integer4 * const restrict pwhich, integer4 array_length);
FCC_API void _fcc_cshift1_8 (fcc_array_char * const restrict ret,	const fcc_array_char * const restrict array,
	const fcc_array_i8 * const restrict h, 	const integer8 * const restrict pwhich);
FCC_API void _fcc_cshift1_8_char (fcc_array_char * const restrict ret, 	integer4 ret_length, const fcc_array_char * const restrict array,
	const fcc_array_i8 * const restrict h, 	const integer8 * const restrict pwhich, integer4 array_length);
FCC_API void  _fcc_eoshift0_4 (fcc_array_char *ret, const fcc_array_char *array, const integer4 *pshift,
						   const char *pbound,	const integer4 *pdim);
FCC_API void _fcc_eoshift0_4_char (fcc_array_char *ret,	integer4 ret_length, const fcc_array_char *array,
   const integer4 *pshift, const char *pbound, const integer4 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift0_4_char4 (fcc_array_char4 *ret,	integer4 ret_length, const fcc_array_char4 *array,
   const integer4 *pshift, const char4 *pbound, const integer4 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void  _fcc_eoshift0_8 (fcc_array_char *ret, const fcc_array_char *array, const integer8 *pshift,
						   const char *pbound,	const integer8 *pdim);
FCC_API void _fcc_eoshift0_8_char (fcc_array_char *ret,	integer4 ret_length, const fcc_array_char *array,
   const integer8 *pshift, const char *pbound, const integer8 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift0_8_char4 (fcc_array_char4 *ret,	integer4 ret_length, const fcc_array_char4 *array,
   const integer8 *pshift, const char4 *pbound, const integer8 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift1_4 (fcc_array_char * const restrict ret, const fcc_array_char * const restrict array,
	const fcc_array_i4 * const restrict h, const char * const restrict pbound, const integer4 * const restrict pwhich);
FCC_API void _fcc_eoshift1_4_char (fcc_array_char * const restrict ret, integer4 ret_length, const fcc_array_char * const restrict array, 
	const fcc_array_i4 * const restrict h, const char *  const restrict pbound, const integer4 * const restrict pwhich,
	integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift1_8 (fcc_array_char * const restrict ret, const fcc_array_char * const restrict array,
	const fcc_array_i8 * const restrict h, const char * const restrict pbound, const integer8 * const restrict pwhich);
FCC_API void _fcc_eoshift1_8_char (fcc_array_char * const restrict ret, integer4 ret_length, const fcc_array_char * const restrict array, 
	const fcc_array_i8 * const restrict h, const char *  const restrict pbound, const integer8 * const restrict pwhich,
	integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift2_4(fcc_array_char *ret, const fcc_array_char *array,	const integer4 *pshift,
							  const fcc_array_char *pbound, const integer4 *pdim);
FCC_API void _fcc_eoshift2_4_char(fcc_array_char *ret, integer4 ret_length, const fcc_array_char *array,
      const integer4 *pshift, const fcc_array_char *pbound,	const integer4 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift2_8(fcc_array_char *ret, const fcc_array_char *array,	const integer8 *pshift,
							  const fcc_array_char *pbound, const integer8 *pdim);
FCC_API void _fcc_eoshift2_8_char(fcc_array_char *ret, integer4 ret_length, const fcc_array_char *array,
      const integer8 *pshift, const fcc_array_char *pbound,	const integer8 *pdim, integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift3_4 (fcc_array_char * const restrict ret, const fcc_array_char * const restrict array,
	const fcc_array_i4 * const restrict h, const fcc_array_char * const restrict bound, const integer4 * const restrict pwhich);
FCC_API void _fcc_eoshift3_4_char (fcc_array_char * const restrict ret, integer4 ret_length, const fcc_array_char * const restrict array, 
	const fcc_array_i4 *  const restrict h, const fcc_array_char * const restrict bound, const integer4 * const restrict pwhich,
	integer4 array_length, integer4 bound_length);
FCC_API void _fcc_eoshift3_8 (fcc_array_char * const restrict ret, const fcc_array_char * const restrict array, const fcc_array_i8 * const restrict h, 
	const fcc_array_char * const restrict bound, const integer8 * const restrict pwhich);
FCC_API void _fcc_eoshift3_8_char (fcc_array_char * const restrict ret, integer4 ret_length, const fcc_array_char * const restrict array, 
	const fcc_array_i8 *  const restrict h, const fcc_array_char * const restrict bound, const integer8 * const restrict pwhich,
	integer4 array_length, integer4 bound_length);

FCC_API void _fcc_maxloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array);
FCC_API void _fcc_mmaxloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array,	fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, logical4 * mask);
FCC_API void _fcc_maxloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array,logical4 * mask);
FCC_API void _fcc_maxloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array,logical4 * mask);
FCC_API void _fcc_maxloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array,logical4 * mask);
FCC_API void _fcc_maxloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array,logical4 * mask);
FCC_API void _fcc_maxloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array,	logical4 * mask);
FCC_API void _fcc_maxloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array,logical4 * mask);
FCC_API void _fcc_maxloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array);
FCC_API void _fcc_mmaxloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array,	fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array,	logical4 * mask);
FCC_API void _fcc_maxloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_i1 (fcc_array_i8 * const restrict retarray,fcc_array_i1 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_i1 (fcc_array_i8 * const restrict retarray,fcc_array_i1 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_i2 (fcc_array_i8 * const restrict retarray,fcc_array_i2 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_i2 (fcc_array_i8 * const restrict retarray,fcc_array_i2 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_i4 (fcc_array_i8 * const restrict retarray,fcc_array_i4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_i4 (fcc_array_i8 * const restrict retarray,fcc_array_i4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_i8 (fcc_array_i8 * const restrict retarray,fcc_array_i8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_i8 (fcc_array_i8 * const restrict retarray,fcc_array_i8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_r4 (fcc_array_i8 * const restrict retarray,fcc_array_r4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_r4 (fcc_array_i8 * const restrict retarray,fcc_array_r4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_r8 (fcc_array_i8 * const restrict retarray,fcc_array_r8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_r8 (fcc_array_i8 * const restrict retarray,fcc_array_r8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_maxloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mmaxloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_smaxloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array);
FCC_API void _fcc_mminloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array);
FCC_API void _fcc_mminloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array);
FCC_API void _fcc_mminloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array);
FCC_API void _fcc_mminloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array);
FCC_API void _fcc_mminloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array);
FCC_API void _fcc_mminloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array);
FCC_API void _fcc_mminloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array,	fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, logical4 * mask);
FCC_API void _fcc_minloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array);
FCC_API void _fcc_mminloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array,logical4 * mask);
FCC_API void _fcc_minloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array);
FCC_API void _fcc_mminloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array,logical4 * mask);
FCC_API void _fcc_minloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array);
FCC_API void _fcc_mminloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array,logical4 * mask);
FCC_API void _fcc_minloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array);
FCC_API void _fcc_mminloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array,logical4 * mask);
FCC_API void _fcc_minloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array);
FCC_API void _fcc_mminloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array,	logical4 * mask);
FCC_API void _fcc_minloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array);
FCC_API void _fcc_mminloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array,fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array,logical4 * mask);
FCC_API void _fcc_minloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array);
FCC_API void _fcc_mminloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array,	fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc0_8_r16 (fcc_array_i8 * const restrict retarray, fcc_array_r16 * const restrict array,	logical4 * mask);
FCC_API void _fcc_minloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_i1 (fcc_array_i4 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_i2 (fcc_array_i4 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_i4 (fcc_array_i4 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_i8 (fcc_array_i4 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_r4 (fcc_array_i4 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_r8 (fcc_array_i4 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_4_r16 (fcc_array_i4 * const restrict retarray, fcc_array_r16 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_i1 (fcc_array_i8 * const restrict retarray, fcc_array_i1 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_i1 (fcc_array_i8 * const restrict retarray,fcc_array_i1 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_i1 (fcc_array_i8 * const restrict retarray,fcc_array_i1 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_i2 (fcc_array_i8 * const restrict retarray, fcc_array_i2 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_i2 (fcc_array_i8 * const restrict retarray,fcc_array_i2 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_i2 (fcc_array_i8 * const restrict retarray,fcc_array_i2 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_i4 (fcc_array_i8 * const restrict retarray, fcc_array_i4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_i4 (fcc_array_i8 * const restrict retarray,fcc_array_i4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_i4 (fcc_array_i8 * const restrict retarray,fcc_array_i4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_i8 (fcc_array_i8 * const restrict retarray, fcc_array_i8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_i8 (fcc_array_i8 * const restrict retarray,fcc_array_i8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_i8 (fcc_array_i8 * const restrict retarray,fcc_array_i8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_r4 (fcc_array_i8 * const restrict retarray, fcc_array_r4 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_r4 (fcc_array_i8 * const restrict retarray,fcc_array_r4 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_r4 (fcc_array_i8 * const restrict retarray,fcc_array_r4 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_r8 (fcc_array_i8 * const restrict retarray, fcc_array_r8 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_r8 (fcc_array_i8 * const restrict retarray,fcc_array_r8 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_r8 (fcc_array_i8 * const restrict retarray,fcc_array_r8 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_minloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim);
FCC_API void _fcc_mminloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim, fcc_array_l1 * const restrict mask);
FCC_API void _fcc_sminloc1_8_r16 (fcc_array_i8 * const restrict retarray,fcc_array_r16 * const restrict array, const index_type * const restrict pdim, logical4 * mask);
FCC_API void _fcc_reshape_c16 (fcc_array_c16 * const restrict ret, 	fcc_array_c16 * const restrict source, 	shape_type * const restrict shape,
	fcc_array_c16 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape_c4 (fcc_array_c4 * const restrict ret, fcc_array_c4 * const restrict source, shape_type * const restrict shape,
	fcc_array_c4 * const restrict pad, 	shape_type * const restrict order);
FCC_API void _fcc_reshape_c8 (fcc_array_c8 * const restrict ret, fcc_array_c8 * const restrict source, shape_type * const restrict shape,
	fcc_array_c8 * const restrict pad, 	shape_type * const restrict order);
FCC_API void _fcc_reshape_4 (fcc_array_i4 * const restrict ret, fcc_array_i4 * const restrict source, shape_type * const restrict shape,
	 fcc_array_i4 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape_8 (fcc_array_i8 * const restrict ret, fcc_array_i8 * const restrict source, shape_type * const restrict shape,
	fcc_array_i8 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape_r16 (fcc_array_r16 * const restrict ret, fcc_array_r16 * const restrict source, shape_type * const restrict shape,
	fcc_array_r16 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape_r4 (fcc_array_r4 * const restrict ret, fcc_array_r4 * const restrict source, shape_type * const restrict shape,
	fcc_array_r4 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape_r8 (fcc_array_r8 * const restrict ret, fcc_array_r8 * const restrict source, shape_type * const restrict shape,
	fcc_array_r8 * const restrict pad, shape_type * const restrict order);
FCC_API void _fcc_reshape (fcc_parray *ret, fcc_parray *source, shape_type *shape, fcc_parray *pad, shape_type *order);
FCC_API void _fcc_reshape_char (fcc_parray *ret, charlen_type ret_length, fcc_parray *source, shape_type *shape, fcc_parray *pad,
	      shape_type *order, charlen_type source_length, charlen_type pad_length);
FCC_API void _fcc_reshape_char4 (fcc_parray *ret, charlen_type ret_length, fcc_parray *source, shape_type *shape, fcc_parray *pad,
	      shape_type *order, charlen_type source_length, charlen_type pad_length);
FCC_API int _fcc_associated(const fcc_array_void *pointer, const fcc_array_void *target);
FCC_API void _fcc_pack (fcc_array_char*, const fcc_array_char*, const fcc_array_l1*, const fcc_array_char*);
FCC_API void _fcc_pack_char (fcc_array_char*, integer4, const fcc_array_char*, const fcc_array_l1*, const fcc_array_char*, integer4, integer4);
FCC_API void _fcc_pack_char4 (fcc_array_char4*, integer4, const fcc_array_char4*, const fcc_array_l1*, const fcc_array_char4*, integer4, integer4);
FCC_API void _fcc_pack_s (fcc_array_char*, const fcc_array_char*, const logical4*, const fcc_array_char*);
FCC_API void _fcc_pack_s_char (fcc_array_char*, integer4, const fcc_array_char *, const logical4*, const fcc_array_char *, integer4, integer4);
FCC_API void _fcc_unpack1 (fcc_array_char*, const fcc_array_char*, const fcc_array_l1*, const fcc_array_char*);
FCC_API void _fcc_unpack1_char (fcc_array_char*, integer4, const fcc_array_char*, const fcc_array_l1*, const fcc_array_char*, integer4, integer4);
FCC_API void _fcc_unpack0 (fcc_array_char*, const fcc_array_char*, const fcc_array_l1*, char*);
FCC_API void _fcc_unpack0_char (fcc_array_char*, integer4, const fcc_array_char*, const fcc_array_l1*, char*, integer4, integer4);
FCC_API void _fcc_unpack0_char4 (fcc_array_char4*, integer4, const fcc_array_char4*, const fcc_array_l1*, char4*, integer4, integer4);

FCC_API complex16 _fcc_pow_c16_i4 (complex16 a, integer4 b);
FCC_API complex16 _fcc_pow_c16_i8 (complex16 a, integer8 b);
FCC_API complex4 _fcc_pow_c4_i4 (complex4 a, integer4 b);
FCC_API complex4 _fcc_pow_c4_i8 (complex4 a, integer8 b);
FCC_API complex8 _fcc_pow_c8_i4 (complex8 a, integer4 b);
FCC_API complex8 _fcc_pow_c8_i8 (complex8 a, integer8 b);
FCC_API integer4 _fcc_pow_i4_i4 (integer4 a, integer4 b);
FCC_API integer4 _fcc_pow_i4_i8 (integer4 a, integer8 b);
FCC_API integer8 _fcc_pow_i8_i4 (integer8 a, integer4 b);
FCC_API integer8 _fcc_pow_i8_i8 (integer8 a, integer8 b);
FCC_API real16 _fcc_pow_r16_i4 (real16 a, integer4 b);
FCC_API real16 _fcc_pow_r16_i8 (real16 a, integer8 b);
FCC_API real4 _fcc_pow_r4_i4 (real4 a, integer4 b);
FCC_API real4 _fcc_pow_r4_i8 (real4 a, integer8 b);
FCC_API real8 _fcc_pow_r8_i4 (real8 a, integer4 b);
FCC_API real8 _fcc_pow_r8_i8 (real8 a, integer8 b);
FCC_API void _fcc_shape_4 (fcc_array_i4 * const restrict ret, const fcc_array_i4 * const restrict array);
FCC_API void _fcc_shape_8 (fcc_array_i8 * const restrict ret, const fcc_array_i8 * const restrict array);


FCC_API int _fcc_fgetc (const int * unit, char * c, charlen_type c_len);
FCC_API void _fcc_fgetc_i1_sub(const int * unit, char * c, integer1 * st, charlen_type c_len);
FCC_API void _fcc_fgetc_i2_sub(const int * unit, char * c, integer2 * st, charlen_type c_len);
FCC_API void _fcc_fgetc_i4_sub(const int * unit, char * c, integer4 * st, charlen_type c_len);
FCC_API void _fcc_fgetc_i8_sub(const int * unit, char * c, integer8 * st, charlen_type c_len);
FCC_API int _fcc_fget (char * c, charlen_type c_len);
FCC_API void _fcc_fget_i1_sub (char * c, integer1 * st, charlen_type c_len);
FCC_API void _fcc_fget_i2_sub (char * c, integer2 * st, charlen_type c_len);
FCC_API void _fcc_fget_i4_sub (char * c, integer4 * st, charlen_type c_len);
FCC_API void _fcc_fget_i8_sub (char * c, integer8 * st, charlen_type c_len);
FCC_API int _fcc_fputc (const int * unit, char * c, charlen_type c_len __attribute__((unused)));
FCC_API void _fcc_fputc_i1_sub (const int * unit, char * c, integer1 * st, charlen_type c_len);
FCC_API void _fcc_fputc_i2_sub (const int * unit, char * c, integer2 * st, charlen_type c_len);
FCC_API void _fcc_fputc_i4_sub (const int * unit, char * c, integer4 * st, charlen_type c_len);
FCC_API void _fcc_fputc_i8_sub (const int * unit, char * c, integer8 * st, charlen_type c_len);
FCC_API int _fcc_fput (char * c, charlen_type c_len);
FCC_API void _fcc_fput_i1_sub (char * c, integer1 * st, charlen_type c_len);
FCC_API void _fcc_fput_i2_sub (char * c, integer2 * st, charlen_type c_len);
FCC_API void _fcc_fput_i4_sub (char * c, integer4 * st, charlen_type c_len);
FCC_API void _fcc_fput_i8_sub (char * c, integer8 * st, charlen_type c_len);
FCC_API void _fcc_flush_i4 (integer4 *unit);
FCC_API void _fcc_flush_i8 (integer8 *unit);
FCC_API size_t _fcc_ftell (int * unit);
FCC_API logical4 _fcc_isatty_l4 (int *unit);
FCC_API logical8 _fcc_isatty_l8 (int *unit);
FCC_API void _fcc_ttynam (char ** name, charlen_type * name_len, int unit);
FCC_API integer8 _fcc_ftell2 (int * unit);
FCC_API void _fcc_ttynam_sub (int *unit, char * name, charlen_type name_len);
FCC_API void _fcc_ftell_i1_sub (int * unit, integer1 * offset);
FCC_API void _fcc_ftell_i2_sub (int * unit, integer2 * offset);
FCC_API void _fcc_ftell_i4_sub (int * unit, integer4 * offset);
FCC_API void _fcc_ftell_i8_sub (int * unit, integer8 * offset);
FCC_API void _fcc_fseek_sub (int * unit, GFC_IO_INT * offset, int * whence, int * status);

FCC_API float y0f (float x);
FCC_API float y1f (float x);
FCC_API float ynf (int n, float x);
FCC_API float j0f (float x);
FCC_API float j1f (float x);
FCC_API float jnf (int n, float x);




// intrinsics as actual argument
FCC_API integer4 _fcc__abs_i4(integer4 *);
FCC_API integer8 _fcc__abs_i8(integer8 *);
FCC_API real4 _fcc__abs_r4(real4 *);
FCC_API real8 _fcc__abs_r8(real8 *);
FCC_API real16 _fcc__abs_r16(real16 *);
FCC_API real4 _fcc__abs_c4(complex4 *);
FCC_API real8 _fcc__abs_c8(complex8 *);
FCC_API real16 _fcc__abs_c16(complex16 *);
FCC_API real4 _fcc__acos_r4(real4 *);
FCC_API real8 _fcc__acos_r8(real8 *);
FCC_API real16 _fcc__acos_r16(real16 *);
FCC_API real4 _fcc__acosh_r4(real4 *);
FCC_API real8 _fcc__acosh_r8(real8 *);
FCC_API real16 _fcc__acosh_r16(real16 *);
FCC_API real4 _fcc__aimag_c4(complex4 *);
FCC_API real8 _fcc__aimag_c8(complex8 *);
FCC_API real16 _fcc__aimag_c16(complex16 *);
FCC_API real4 _fcc__aint_r4(real4 *);
FCC_API real8 _fcc__aint_r8(real8 *);
FCC_API real16 _fcc__aint_r16(real16 *);
FCC_API real4 _fcc__anint_r4(real4 *);
FCC_API real8 _fcc__anint_r8(real8 *);
FCC_API real16 _fcc__anint_r16(real16 *);
FCC_API real4 _fcc__asin_r4(real4 *);
FCC_API real8 _fcc__asin_r8(real8 *);
FCC_API real16 _fcc__asin_r16(real16 *);
FCC_API real4 _fcc__asinh_r4(real4 *);
FCC_API real8 _fcc__asinh_r8(real8 *);
FCC_API real16 _fcc__asinh_r16(real16 *);
FCC_API real4 _fcc__atan_r4(real4 *);
FCC_API real8 _fcc__atan_r8(real8 *);
FCC_API real16 _fcc__atan_r16(real16 *);
FCC_API real4 _fcc__atan2_r4(real4 *, real4 *);
FCC_API real8 _fcc__atan2_r8(real8 *, real8 *);
FCC_API real16 _fcc__atan2_r16(real16 *, real16 *);
FCC_API real4 _fcc__atanh_r4(real4 *);
FCC_API real8 _fcc__atanh_r8(real8 *);
FCC_API real16 _fcc__atanh_r16(real16 *);
FCC_API complex4 _fcc__conjg_4(complex4 *);
FCC_API complex8 _fcc__conjg_8(complex8 *);
FCC_API complex16 _fcc__conjg_16(complex16 *);
FCC_API real4 _fcc__cos_r4(real4 *);
FCC_API real8 _fcc__cos_r8(real8 *);
FCC_API real16 _fcc__cos_r16(real16 *);
FCC_API complex4 _fcc__cos_c4(complex4 *);
FCC_API complex8 _fcc__cos_c8(complex8 *);
FCC_API complex16 _fcc__cos_c16(complex16 *);
FCC_API real4 _fcc__cos_r4(real4 *);
FCC_API real8 _fcc__cos_r8(real8 *);
FCC_API real16 _fcc__cos_r16(real16 *);
FCC_API real4 _fcc__cosh_r4(real4 *);
FCC_API real8 _fcc__cosh_r8(real8 *);
FCC_API real16 _fcc__cosh_r16(real16 *);
FCC_API integer4 _fcc__dim_i4(integer4 *, integer4 *);
FCC_API integer8 _fcc__dim_i8(integer8 *, integer8 *);
FCC_API real4 _fcc__dim_r4(real4 *, real4 *);
FCC_API real8 _fcc__dim_r8(real8 *, real8 *);
FCC_API real16 _fcc__dim_r16(real16 *, real16 *);
FCC_API real8 _fcc__dprod_r8(real4 *, real4 *);
FCC_API real16 _fcc__dprod_r16(real8 *, real8 *);
FCC_API complex4 _fcc__exp_c4(complex4 *);
FCC_API complex8 _fcc__exp_c8(complex8 *);
FCC_API complex16 _fcc__exp_c16(complex16 *);
FCC_API real4 _fcc__exp_r4(real4 *);
FCC_API real8 _fcc__exp_r8(real8 *);
FCC_API real16 _fcc__exp_r16(real16 *);
FCC_API complex4 _fcc__log_c4(complex4 *);
FCC_API complex8 _fcc__log_c8(complex8 *);
FCC_API complex16 _fcc__log_c16(complex16 *);
FCC_API real4 _fcc__log_r4(real4 *);
FCC_API real8 _fcc__log_r8(real8 *);
FCC_API real16 _fcc__log_r16(real16 *);
FCC_API real4 _fcc__log10_r4(real4 *);
FCC_API real8 _fcc__log10_r8(real8 *);
FCC_API real16 _fcc__log10_r16(real16 *);
FCC_API complex4 _fcc__sin_c4(complex4 *);
FCC_API complex8 _fcc__sin_c8(complex8 *);
FCC_API complex16 _fcc__sin_c16(complex16 *);
FCC_API real4 _fcc__sin_r4(real4 *);
FCC_API real8 _fcc__sin_r8(real8 *);
FCC_API real16 _fcc__sin_r16(real16 *);
FCC_API real4 _fcc__sinh_r4(real4 *);
FCC_API real8 _fcc__sinh_r8(real8 *);
FCC_API real16 _fcc__sinh_r16(real16 *);
FCC_API real4 _fcc__tan_r4(real4 *);
FCC_API real8 _fcc__tan_r8(real8 *);
FCC_API real16 _fcc__tan_r16(real16 *);
FCC_API real4 _fcc__tanh_r4(real4 *);
FCC_API real8 _fcc__tanh_r8(real8 *);
FCC_API real16 _fcc__tanh_r16(real16 *);
FCC_API complex4 _fcc__sqrt_c4(complex4 *);
FCC_API complex8 _fcc__sqrt_c8(complex8 *);
FCC_API complex16 _fcc__sqrt_c16(complex16 *);
FCC_API real4 _fcc__sqrt_r4(real4 *);
FCC_API real8 _fcc__sqrt_r8(real8 *);
FCC_API real16 _fcc__sqrt_r16(real16 *);
FCC_API integer4 _fcc__nint_4_4(real4 *);
FCC_API integer4 _fcc__nint_4_8(real8 *);
FCC_API integer4 _fcc__nint_4_16(real16 *);
FCC_API integer8 _fcc__nint_8_4(real4 *);
FCC_API integer8 _fcc__nint_8_8(real8 *);
FCC_API integer8 _fcc__nint_8_16(real16 *);
FCC_API integer4 _fcc__mod_i4(integer4 *, integer4 *);
FCC_API integer8 _fcc__mod_i8(integer8 *, integer8 *);
FCC_API real4 _fcc__mod_r4(real4 *, real4 *);
FCC_API real8 _fcc__mod_r8(real8 *, real8 *);
FCC_API real16 _fcc__mod_r16(real16 *, real16 *);
FCC_API integer4 _fcc__sign_i4(integer4 *, integer4 *);
FCC_API integer8 _fcc__sign_i8(integer8 *, integer8 *);
FCC_API real4 _fcc__sign_r4(real4 *, real4 *);
FCC_API real8 _fcc__sign_r8(real8 *, real8 *);
FCC_API real16 _fcc__sign_r16(real16 *, real16 *);
FCC_API integer4 _fcc__len_1_i4(char *, index_type);
FCC_API integer8 _fcc__len_1_i8(char *, index_type);
FCC_API integer4 _fcc__index_1_i4(char *, char *, index_type, index_type);
FCC_API integer8 _fcc__index_1_i8(char *, char *, index_type, index_type);
FCC_API void _fcc__char_1_i4(char*, const index_type, const integer4* restrict const);
FCC_API void _fcc__char_1_i8(char*, const index_type, const integer8* restrict const);
FCC_API void _fcc_ctime(char **, charlen_type *, integer8);
FCC_API void _fcc_ctime_sub (integer8 *, char *, charlen_type);
FCC_API void _fcc_fdate_sub (char *, charlen_type);
FCC_API void _fcc_fdate (char **, charlen_type *);

// implementation of not implemented in LIBM functions
#include "c99_protos.h"

#endif /* FCC_H */
