/*
 * @(#)libmatlb.h    generated by: makeheader    Thu Jan 21 01:45:03 1999
 *
 *		built from:	headers/copyright.h
 *				mlm/memory.c
 *				mlm/stubs.c
 *				mlm/handler.c
 *				mlm/mlm.c
 *				mlm/varargs.c
 *				mlm/mlmdispatch.c
 *				mlm/index.c
 *				mlm/mlmscalar.c
 *				mlm/builtins.c
 *				mlm/mlmsparse.c
 *				mlm/mxapi.c
 *				mlm/mex_interface.c
 */

#ifndef libmatlb_h
#define libmatlb_h


/*
 * Copyright (c) 1984-1998 by The MathWorks, Inc.
 * All Rights Reserved.
 */

#ifdef __cplusplus
    extern "C" {
#endif

extern void mlfSetLibraryAllocFcns(calloc_proc calloc_fcn, free_proc free_fcn,
                                   realloc_proc realloc_fcn, malloc_proc malloc_fcn);

extern void mclInitMemoryCache(void);


typedef void (*ErrorHandlerFcn)(const char*, bool);



#ifndef __cplusplus
static mxArray *__mclUnassignedArray = NULL;
static mxArray *__mclUninitializedArray = NULL;

#ifdef __GNUC__
static void __mcl_nowarn(void)
{
    (void)__mclUnassignedArray;
    (void)__mclUninitializedArray;
    (void)__mcl_nowarn;
}
#endif

#define mclUnassigned() (__mclUnassignedArray==NULL?\
                         (__mclUnassignedArray=mclGetUnassignedArray()):__mclUnassignedArray)
#define mclInitializeAns() (__mclUninitializedArray==NULL?\
                            (__mclUninitializedArray=mclGetUninitializedArray()):__mclUninitializedArray)
#else
#define mclUnassigned() mclGetUnassignedArray()
#define mclInitializeAns() mclGetUninitializedArray()
#endif

#define mclInitializeNull() mclInitializeAns()
#define mclIsInitialized(pa) (pa != NULL && mxGetClassID(pa) != mxUNKNOWN_CLASS)


#ifdef __cplusplus
#define mclMline( line ) __M_line_number = line;
#ifdef EXCEPTIONS_WORK
#define mclMlineEnterFunction( file_name, function_name ) \
{ const char * volatile __M_file_name = file_name; \
  const char * volatile __M_function_name = function_name; \
  volatile size_t __M_line_number = 0; \
  try {
#define mclMlineExitFunction() \
  } catch (mwException &) { \
      mclAppendMlineToError( (const char *) __M_file_name, (const char *) __M_function_name, (size_t) __M_line_number ); \
      error( lasterror() ); \
  } }
#else
#define mclMlineEnterFunction( file_name, function_name ) \
{ const char * volatile __M_file_name = file_name; \
  const char * volatile __M_function_name = function_name; \
  volatile size_t __M_line_number = 0; 
#define mclMlineExitFunction() \
  }
#endif
#else
#define mclMlineEnterFunction( file_name, function_name ) \
{ const char * volatile __M_file_name = file_name; \
  const char * volatile __M_function_name = function_name; \
  volatile size_t __M_line_number = 0; \
  mlfTry {
#define mclMline( line ) __M_line_number = line;
#define mclMlineExitFunction() \
  } mlfCatch { \
      mclAppendMlineToError( (const char *) __M_file_name, (const char *) __M_function_name, (size_t) __M_line_number ); \
      mlfError( mlfLasterror(NULL) ); \
  } mlfEndCatch }
#endif


extern void mclAppendMlineToError(const char *file_name, const char *function_name, size_t line_number );

extern mxArray *mclGetUninitializedArray(); 

extern mxArray *mclGetUnassignedArray();


extern void mclErrorIfUnassigned(mxArray *pa); 


extern bool mclIsCommaList(mxArray *array);


extern bool mclIsNewContext(void);

extern void mclDestroyArray(mxArray *a); 
 
/* For use only by the compiler. Do not call this function */
extern bool mclIsTempArray(mxArray *a); 
 
/* For use only by the compiler. Do not call this function */
extern void mclFixInternalMatrix(mxArray *a);

extern mxArray *mclCreateGlobal(void); 
extern void mclMoveArraysToCurrentContext(int count, mxArray **ppa); 

/* This function is intended for use only by the MATLAB compiler. */
extern void mclAssignLastValue(mxArray **ans);

 
/* This function is intended for use only by the MATLAB compiler. */
extern mxArray *mclAssignAns(mxArray * volatile *dest, mxArray *src); 


extern void mclCopyInputArg(mxArray * volatile *dest, mxArray *src);

extern mxArray *mlfReturnValue(mxArray *a); 


extern void mclCopyOutputArg(mxArray * volatile *dest, mxArray *src);


extern mxArray *mclPrintAns(mxArray * volatile *dest, mxArray *src); 

extern mxArray *mlfAssign(mxArray * volatile *dest, mxArray *src); 

extern void mlfClear(mxArray * volatile *var, ...);

extern mxArray *mclInitialize(mxArray *pa);

extern void mclValidateInputs(const char* fname, int nargs, ...);

extern void mclValidateOutputs(const char* fname, int noutputs, int nargout, ...);

extern void mclCopyArray(mxArray **pa);

extern void mlfEnterNewContext(int nout, int nin, ...);

extern void mlfRestorePreviousContext(int nout, int nin, ...);

extern void mclFevalExec(void (*mxfn)(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs),
                         int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);

extern ErrorHandlerFcn mlfSetErrorHandler(ErrorHandlerFcn EH);

extern int mlfPrintf(const char* fmt, ...);

extern void mlfSetPrintHandler(void (* PH)(const char *));

extern void mlfInitFcn(void);

extern void mlfCleanupFcn(void);

extern void mlfCleanupOutputArray(mxArray* pa);


#include <setjmp.h>



typedef void (*mclExceptionFcn)(void*);

typedef struct mclErrorContext_tag
{
  int depth;
  int allocContext;
  int arrayContext;
  int libraryContext;
} mclErrorContext;

typedef struct mclTryCatchContext_tag
{
  mclErrorContext err_ctx;
  int err_mode;
  jmp_buf *buffer;
  ErrorHandlerFcn err_handler;
  mclExceptionFcn except_fcn;
} mclTryCatchContext;
  

extern void mclNewErrorContext(mclErrorContext *errorCtx);

extern void mclRestoreErrorContext(mclErrorContext *errorCtx); 


typedef struct mclErrorContext_tag mclCppContext;
#define mclExitCppContext mclRestoreErrorContext

extern void mclEnterCppContext(mclCppContext *cppCtx);

extern void mclCppError(mclCppContext *cppCtx);

extern void mclMexError(void);

extern jmp_buf *mclGetSetjmpData();

extern void mclEnterTryCatchContext(mclTryCatchContext *ctx, jmp_buf *newbuf, mclExceptionFcn exception_fcn);

extern void mclExitTryCatchContext(mclTryCatchContext *ctx, int err_flag);


#ifdef MLF_ENABLE_TRYCATCH 

static void _mclExceptionFcn(void* msg)
{
    mclExceptionFcn dummy;
    dummy = _mclExceptionFcn; msg = 0;/* Prevents compiler warning */
    longjmp(*mclGetSetjmpData(), -1);
}

/*
 * Consider the following C source:
 *
 *   typedef long jb[5];
 *   ...
 *   jb b;
 *   jb *x = &b
 *
 * This causes the alpha compiler (and maybe others) to issue two warnings:
 *
 *   ... & before array "b" is ignored ...
 *
 *   ... the referenced type of the pointer value "&b" is "long",
 *       which is not compatible with "array [5] of long"
 *
 * Thus rather than &_mcl_tcbuf, which is what you might think is right,
 * the pointer needed in the second argument to mclEnterTryCatchContext is
 * obtained with a cast.
 */
#define mlfTry \
{ \
    jmp_buf _mcl_tcbuf; \
    mclTryCatchContext _mcl_ctx; \
    mclEnterTryCatchContext(&_mcl_ctx, (jmp_buf *)_mcl_tcbuf, _mclExceptionFcn); \
    if (!setjmp(_mcl_tcbuf)) {

#define mlfCatch \
        mclExitTryCatchContext(&_mcl_ctx, 0); \
    } else {{ \
        mclExitTryCatchContext(&_mcl_ctx, 1);

#define mlfEndCatch }}}

#endif


extern mxArray * mlfLasterr(mxArray * OI1);


extern void mlxLasterr(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);


#define mlfLasterror mlfLasterr

extern bool mclIsOutOfMemoryError(void); 

extern mxArray * mlfScalar(double v);

extern mxArray * mlfComplexScalar(double v, double i);

extern mxArray * mlfDoubleMatrix(int m, int n, const double *pr, const double *pi);

extern double *mlfGetPr(mxArray *pa);

extern void mlfSetPr(mxArray *pa, double *pr);

extern double *mlfGetPi(mxArray *pa);

extern void mlfSetPi(mxArray *pa, double *pi);

extern bool mclSwitchCompare(mxArray *switchvar, mxArray *casevar);

extern mxArray * mclCreateEmptyArray(void );


#define mclArrayToInt(x) ((int)(*mxGetPr(x)))
#define mlfBuiltin mlfVarargFeval

extern mxArray * mclCreateCellFromStrings(int count, const char** strings);

extern mxArray * mclCreateEmptyCell();

extern mxArray * mlfI(void);


#define mlfJ() mlfI()

extern bool mlfTobool(mxArray *RI1);

extern void mlfAddFlops(double f);

extern void mlfSetLibraryCalloc(void *func);

extern void mlfSetLibraryMalloc(void *func);

extern void mlfSetLibraryFree(void *func);

extern void mlfPrintMatrix(mxArray *RI1);

extern void mclPrintArray(mxArray *RI1, const char *name);

extern void mlfSave(mxArray *file, const char* mode, ... );

extern void mlfSave_v12(const char* file, const char* mode, ...);

extern void mlfLoad(mxArray *file, ... );

extern void mlfLoad_v12(const char* file, ...);

extern mxArray *mclCreateStructFromMatFile(mxArray *matfile, int numfields, char **names);

extern mxArray *mlfLoadStruct(mxArray *matfile, const char* name, ...);


#ifndef MLF_ENABLE_ND_ARRAYS
#define mlfSave mlfSave_v12
#define mlfLoad mlfLoad_v12
#endif


#include <stdarg.h>

#define MLFMAXVAR 100

#define mlfVararginDecls \
    int nrhs = 0, size = MLFMAXVAR; \
    mxArray *prhslocal[MLFMAXVAR], **prhs = prhslocal; \
    mxArray *patemp;

#define mlfVararginBody(varargin, last, uselast, ap) \
    if (uselast) { \
        patemp = last; \
    } else { \
        patemp = va_arg(ap, mxArray *); \
    } \
    while(patemp != NULL) { \
        prhs[nrhs++] = patemp; \
        if (nrhs == size) { \
            size = mclExpandVararginList(&prhs, size); \
        } \
        patemp = va_arg(ap, mxArray *); \
    } \
    mlfAssign(varargin, mclUnpackVararginToCell(nrhs, prhs)); \
    if (prhs != prhslocal) mxFree(prhs);

/* mlfVarargin assigns, via the varargin argument, a cell array which is temporary and
 * is in the caller's array list context.  Any temporary inputs to the varargs function
 * will be owned by the cell array.  The cell array will have a reference count of 1,
 * and must be explicitly destroyed.  */

/* Can't pass a va_list to a library compiled with a non-default compiler.  */
#if (defined(__WATCOMC__) || defined(__BORLANDC__) || (defined(__GNUC__) && !defined(__linux__)))
#define mlfVarargin( varargin, last, uselast) \
{ \
    mlfVararginDecls \
    va_list ap; \
    va_start(ap, last); \
    mlfVararginBody(varargin, (mxArray*)last, uselast, ap) \
    va_end(ap); \
}
#else
#define mlfVarargin( varargin, last, uselast) \
{ \
    va_list ap; \
    va_start(ap, last); \
    mclVarargin(varargin, (mxArray*)(void*)last, uselast, ap); \
    va_end(ap); \
}
#endif

 
/* For math library use only.  Do not call this function.*/
extern int mclExpandVararginList(mxArray ***prhs, int size); 

extern int mclUnpackCommaList(mxArray **prhs, mxArray *m, bool to_cell, bool is_cpp_array);

 
/* For math library use only.  Do not call this function.*/
extern mxArray *mclUnpackVararginToCell(int nrhs, mxArray **prhs);


extern void mclVarargin(mxArray ** varargin, mxArray * last, int uselast, va_list ap);


extern int mlfCountVarargin(va_list ap, mxArray *first);


/* For math library use only.  Do not call this function.*/
extern void mlfUnpackVarargin(va_list ap, mxArray **prhs, mxArray *first);

extern mxArray *mlfCellhcat(mxArray *pa, ...);

extern void mlxCellhcat(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);

extern mxArray *mlfNargin(int varargin_flag, ...);


typedef struct mlfVarargoutList_tag mlfVarargoutList;

extern int mlfNargout(mlfVarargoutList *varargout);

extern mlfVarargoutList *mlfIndexVarargout(mxArray **ppa, ...); 
extern mlfVarargoutList *mlfVarargout(mxArray **ppa, ...); 

extern mxArray *mlfGetVarargoutCell(mlfVarargoutList *v);

extern mxArray **mlfGetVarargoutCellPtr(mlfVarargoutList *v);

extern mlfVarargoutList *mclAnsVarargout(void); 

extern mlfVarargoutList *mclNVarargout(int nargout, int varargout_used, ...); 

extern mlfVarargoutList *mclValueVarargout(void); 

extern mxArray *mlfAssignOutputs(mlfVarargoutList *v);

extern void mclCreateVarargoutCell(mlfVarargoutList *vout, int nvarargs, mxArray **ppa);

extern mxArray * mlfVarargFeval(mlfVarargoutList *varargout,
                                void (*mxfn)(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs), ...);


extern void mclAssignVarargoutCell(int nlhs, mxArray *plhs[], mxArray *cell);


extern mxArray *mclCreateVararginCell(int nrhs, mxArray *prhs[]);


typedef void (*mlfFcnPtr)(int, mxArray**, int, mxArray**);



typedef struct mlfDispatchTable_tag 
{
  mlfFcnPtr *vtab;
  const char** funcnames;
  int nfuncs;
} mlfDispatchTable;



/* For math library use only.  Do not call this function */
extern void mlfDispatch(int nlhs, mxArray** plhs, int nrhs, mxArray** prhs,
                 int code, mlfDispatchTable *dt);


#define MLF_DEFAULT_INDEX_SIZE 4

typedef unsigned char mlfIndexType;
struct mlfIndexDef_tag
{
    int num_index_ops;
    mlfIndexType *type;
    int *idx;
    mxArray **subscripts;
    int  *fieldptrs;
    char *fieldnames;
    mlfIndexType type_local[MLF_DEFAULT_INDEX_SIZE];
    int idx_local[MLF_DEFAULT_INDEX_SIZE+1];
    mxArray *subscripts_local[MLF_DEFAULT_INDEX_SIZE];
    int fieldptrs_local[MLF_DEFAULT_INDEX_SIZE+1];
    char fieldnames_local[MLF_DEFAULT_INDEX_SIZE];
    mxArray **dest;
    int size;
    int max_size;
};
#define mlfCELL 0
#define mlfARRAY 1
#define mlfSTRUCT 2
typedef struct mlfIndexDef_tag mlfIndexDef;


/* For use only by the C++ math library. Do not call this function. */
extern void mclInitIndex(mlfIndexDef *index_def);

extern void mclDestroyIndexDef(mlfIndexDef *index_def, int free_flag); 
extern void mclCopyIndexDef(mlfIndexDef *dest, const mlfIndexDef *src);


/* For use only by the C++ math library. Do not call this function. */
extern void mclAddIndex(mlfIndexDef *index_def, mlfIndexType type, int nsubscripts, mxArray **psubscripts);


extern void mclAddFieldToLastIndex(mlfIndexDef *index_def, const char* fname_in);


/* For use only by the C++ math library. Do not call this function. */
extern mxArray *mclComplexRef(mxArray *pa, mlfIndexDef *index_def);

 
/* This function is intended for use only by the C++ math library */
extern void mclComplexAssign(mlfIndexDef *index_def, mxArray *src, bool packCell);

extern void mclPrintIndex(const char* index_string, ...);

extern mxArray * mlfIndexRef(mxArray *pa, const char* index_string, ...);

extern mxArray * mlfIndexAssign(mxArray * volatile *pa, const char* index, ...);

extern mxArray * mlfIndexDelete(mxArray * volatile *pa, const char* index, ...);

extern mxArray* mlfArrayRef(mxArray *array, ...);

extern void mlfArrayAssign(mxArray *dest, mxArray *src, ...);

extern void mlfArrayDelete(mxArray *dest, ...);

extern mxArray * mlfCreateColonIndex();

extern bool mlfIsColonIndex(mxArray *a);


extern int mclGetNumberOfIndexedElements(mlfIndexDef *index_def); 


/* For use only by the C++ math library */
extern int mclMultiAssign(mlfIndexDef *index_def, mxArray **prhs, int max_rhs_size);


/* For use only by the Matlab compiler. This is unsupported functionality. */
typedef struct mclForIter_tag {
    int curridx;  /* Current index into loop array */
    int maxidx;   /* maximum index into loop array */
    mxArray *loop_array;  /* array over which we are iterating, (null if colon index) */
    mxArray *row; /* row index (null if colon index) */ 
    mxArray *col; /* column index (null if colon index)*/
    double start; /* start value (ignored if not colon) */ 
    double delta; /* step value (ignored if not colon) */ 
} mclForLoopIterator;
#define mclForDone 0

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclDestroyForLoopIterator(mclForLoopIterator *piter);

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclForStart(mclForLoopIterator *piter, mxArray *pa, mxArray *pa2, mxArray *pa3);


typedef mxArray * volatile *mclVolatileArrayPtr;

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern int mclForNext(mclForLoopIterator *piter, mclVolatileArrayPtr ppa); 

extern mxArray * mlf_colonobj(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlf_license_checkout(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfAbs(mxArray *in1);

extern mxArray * mlfAcos(mxArray *in1);

extern mxArray * mlfAcosh(mxArray *in1);

extern void mlfAdd_block(mxArray *in1, ...);

extern void mlfAdd_line(mxArray *in1, ...);

extern mxArray * mlfAll(mxArray *in1, mxArray *in2);

extern mxArray * mlfAnd(mxArray *in1, mxArray *in2);

extern mxArray * mlfAny(mxArray *in1, mxArray *in2);

extern mxArray * mlfApplescript(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfAsin(mxArray *in1);

extern mxArray * mlfAsinh(mxArray *in1);

extern mxArray * mlfAssignin(mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern mxArray * mlfAtan(mxArray *in1);

extern mxArray * mlfAtanh(mxArray *in1);

extern mxArray * mlfAtan2(mxArray *in1, mxArray *in2);

extern mxArray * mlfBalance(mxArray **out1, mxArray *in1);

extern mxArray * mlfBitand(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitcmp(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitget(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitset(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfBitshift(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfBitor(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitxor(mxArray *in1, mxArray *in2);

extern mxArray * mlfCallstats(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfCat(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfCd(mxArray *in1);

extern mxArray * mlfCeil(mxArray *in1);

extern mxArray * mlfCell(mxArray *in1, ...);

extern mxArray * mlfCell2struct(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfChar(mxArray *in1, ...);

extern mxArray * mlfChdir(mxArray *in1);

extern mxArray * mlfChol(mxArray **out1, mxArray *in1);

extern mxArray * mlfCholinc(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfCholupdate(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfClassName(mxArray *in1);

extern void mlfClc( void );

extern mxArray * mlfClock( void );

extern void mlfClose_system(mxArray *in1, ...);

extern mxArray * mlfColon(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfComputer(mxArray **out1);

extern mxArray * mlfConj(mxArray *in1);

extern mxArray * mlfConv2(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfCos(mxArray *in1);

extern mxArray * mlfCtranspose(mxArray *in1);

extern mxArray * mlfCosh(mxArray *in1);

extern mxArray * mlfCumprod(mxArray *in1, mxArray *in2);

extern mxArray * mlfCumsum(mxArray *in1, mxArray *in2);

extern mxArray * mlfCputime( void );

extern void mlfDbclear(mxArray *in1, ...);

extern void mlfDbdown( void );

extern void mlfDbquit( void );

extern mxArray * mlfDbstack(mxArray **out1);

extern mxArray * mlfDbstatus(mxArray *in1, ...);

extern void mlfDbstep(mxArray *in1);

extern void mlfDbstop(mxArray *in1, ...);

extern void mlfDbtype(mxArray *in1);

extern void mlfDbup( void );

extern void mlfDelete_block(mxArray *in1);

extern void mlfDelete_line(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfDet(mxArray *in1);

extern mxArray * mlfDiag(mxArray *in1, mxArray *in2);

extern void mlfDiary(mxArray *in1);

extern mxArray * mlfDiff(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfDir(mxArray *in1);

extern void mlfDisp(mxArray *in1);

extern mxArray * mlfDongarra(mxArray *in1);

extern mxArray * mlfDouble(mxArray *in1);

extern mxArray * mlfDos(mxArray **out1, mxArray *in1, mxArray *in2);

extern void mlfEcho(mxArray *in1, ...);

extern mxArray * mlfEdt(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfEnd(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfEig(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfEps( void );

extern mxArray * mlfEq(mxArray *in1, mxArray *in2);

extern void mlfError(mxArray *in1);

extern mxArray * mlfErrorstat( void );

extern void mlfErrortrap(mxArray *in1);

extern mxArray * mlfEvalin(mlfVarargoutList *varargout, mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern mxArray * mlfNEvalin(int nargout, mlfVarargoutList *varargout, mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern void mlfExit( void );

extern mxArray * mlfExp(mxArray *in1);

extern mxArray * mlfExpm(mxArray *in1);

extern mxArray * mlfEye(mxArray *in1, mxArray *in2);

extern mxArray * mlfFclose(mxArray *in1);

extern void mlfFeature(mxArray *in1, ...);

extern mxArray * mlfFieldnames(mxArray *in1);

extern mxArray * mlfFields(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfFeof(mxArray *in1);

extern mxArray * mlfFerror(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfFft(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFftn(mxArray *in1, mxArray *in2);

extern mxArray * mlfFgets(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfFilter(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4, mxArray *in5);

extern mxArray * mlfFind(mxArray **out1, mxArray **out2, mxArray *in1);

extern mxArray * mlfFindstr(mxArray *in1, mxArray *in2);

extern mxArray * mlfFinite(mxArray *in1);

extern mxArray * mlfFix(mxArray *in1);

extern mxArray * mlfFloor(mxArray *in1);

extern mxArray * mlfFlops(mxArray *in1);

extern void mlfFormat(mxArray *in1, mxArray *in2);

extern mxArray * mlfFopen(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFprintf(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfFread(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfFschange(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfFscanf(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFseek(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFtell(mxArray *in1);

extern mxArray * mlfFull(mxArray *in1);

extern mxArray * mlfFwrite(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfGe(mxArray *in1, mxArray *in2);

extern mxArray * mlfGet_param(mxArray *in1, mxArray *in2);

extern mxArray * mlfGetenv(mxArray *in1);

extern mxArray * mlfGetfield(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfGt(mxArray *in1, mxArray *in2);

extern mxArray * mlfHcreate(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfHardcopy(mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern mxArray * mlfHelp(mxArray *in1);

extern void mlfHome( void );

extern mxArray * mlfHess(mxArray **out1, mxArray *in1);

extern mxArray * mlfHorzcat(mxArray *in1, ...);

extern mxArray * mlfHregister(mxArray *in1, ...);

extern mxArray * mlfImag(mxArray *in1);

extern mxArray * mlfInf( void );

extern void mlfInferiorto(mxArray *in1, ...);

extern mxArray * mlfInmem(mxArray **out1);

extern mxArray * mlfInput(mxArray *in1, mxArray *in2);

extern mxArray * mlfInputname(mxArray *in1);

extern mxArray * mlfInt8(mxArray *in1);

extern mxArray * mlfInt16(mxArray *in1);

extern mxArray * mlfInt32(mxArray *in1);

extern mxArray * mlfInv(mxArray *in1);

extern mxArray * mlfIsa(mxArray *in1, mxArray *in2);

extern mxArray * mlfIsequal(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfIsempty(mxArray *in1);

extern mxArray * mlfIsfinite(mxArray *in1);

extern mxArray * mlfIsglobal(mxArray *in1);

extern mxArray * mlfIsieee( void );

extern mxArray * mlfIsjava(mxArray *in1, ...);

extern mxArray * mlfIssparse(mxArray *in1);

extern mxArray * mlfIscell(mxArray *in1);

extern mxArray * mlfIschar(mxArray *in1);

extern mxArray * mlfIslogical(mxArray *in1);

extern mxArray * mlfIsstr(mxArray *in1);

extern mxArray * mlfIsstudent( void );

extern mxArray * mlfIsinf(mxArray *in1);

extern mxArray * mlfIsletter(mxArray *in1);

extern mxArray * mlfIsnan(mxArray *in1);

extern mxArray * mlfIsreal(mxArray *in1);

extern mxArray * mlfIsspace(mxArray *in1);

extern mxArray * mlfJava(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfJava_method(mxArray *in1, ...);

extern mxArray * mlfJava_object(mxArray *in1, ...);

extern void mlfKeyboard( void );

extern mxArray * mlfLastwarn(mxArray *in1);

extern mxArray * mlfLength(mxArray *in1);

extern mxArray * mlfLdivide(mxArray *in1, mxArray *in2);

extern mxArray * mlfLe(mxArray *in1, mxArray *in2);

extern mxArray * mlfLinmod(mxArray **out1, mxArray **out2, mxArray **out3, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfLog(mxArray *in1);

extern mxArray * mlfLog2(mxArray **out1, mxArray *in1);

extern mxArray * mlfLogical(mxArray *in1);

extern void mlfLookfor(mxArray *in1);

extern mxArray * mlfLower(mxArray *in1);

extern mxArray * mlfLt(mxArray *in1, mxArray *in2);

extern mxArray * mlfLtifr(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfLtitr(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfLu(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2);

extern mxArray * mlfLuinc(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2);

extern mxArray * mlfMacprint(mxArray *in1, ...);

extern mxArray * mlfMactools(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfMagic(mxArray *in1);

extern mxArray * mlfMax(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfMethods(mxArray *in1);

extern mxArray * mlfMexext( void );

extern mxArray * mlfMfilename( void );

extern mxArray * mlfMfile2struct(mxArray *in1);

extern mxArray * mlfMin(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfMinus(mxArray *in1, mxArray *in2);

extern void mlfMislocked(mxArray *in1);

extern void mlfMlock( void );

extern mxArray * mlfMldivide(mxArray *in1, mxArray *in2);

extern mxArray * mlfMpower(mxArray *in1, mxArray *in2);

extern mxArray * mlfMrdivide(mxArray *in1, mxArray *in2);

extern mxArray * mlfMtimes(mxArray *in1, mxArray *in2);

extern mxArray * mlfMore(mxArray *in1);

extern void mlfMunlock(mxArray *in1);

extern mxArray * mlfNan( void );

extern mxArray * mlfNdims(mxArray *in1);

extern mxArray * mlfNe(mxArray *in1, mxArray *in2);

extern mxArray * mlfNeq(mxArray *in1, mxArray *in2);

extern void mlfNew_system(mxArray *in1);

extern mxArray * mlfNorm(mxArray *in1, mxArray *in2);

extern mxArray * mlfNot(mxArray *in1);

extern mxArray * mlfOnes(mxArray *in1, ...);

extern void mlfOpen_system(mxArray *in1, mxArray *in2);

extern mxArray * mlfOr(mxArray *in1, mxArray *in2);

extern mxArray * mlfOverload(mlfVarargoutList *varargout, mxArray *in1, ...);

extern void mlfPack( void );

extern void mlfPause(mxArray *in1, ...);

extern void mlfPfile(mxArray *in1, ...);

extern mxArray * mlfPermute(mxArray *in1, mxArray *in2);

extern mxArray * mlfPi( void );

extern mxArray * mlfPlus(mxArray *in1, mxArray *in2);

extern mxArray * mlfPow2(mxArray *in1, mxArray *in2);

extern mxArray * mlfProd(mxArray *in1, mxArray *in2);

extern mxArray * mlfPower(mxArray *in1, mxArray *in2);

extern mxArray * mlfQr(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfQrupdate(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern void mlfQuit(mxArray *in1);

extern mxArray * mlfQz(mxArray **out1, mxArray **out2, mxArray **out3, mxArray **out4, mxArray *in1, mxArray *in2);

extern mxArray * mlfRand(mxArray *in1, ...);

extern mxArray * mlfRandn(mxArray *in1, ...);

extern mxArray * mlfRcond(mxArray *in1);

extern mxArray * mlfRdivide(mxArray *in1, mxArray *in2);

extern mxArray * mlfReal(mxArray *in1);

extern mxArray * mlfRealmax( void );

extern mxArray * mlfRealmin( void );

extern mxArray * mlfRem(mxArray *in1, mxArray *in2);

extern mxArray * mlfReshape(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfRound(mxArray *in1);

extern mxArray * mlfSchur(mxArray **out1, mxArray *in1);

extern mxArray * mlfSetfield(mxArray *in1, mxArray *in2, ...);

extern void mlfSet_param(mxArray *in1, ...);

extern mxArray * mlfSetstr(mxArray *in1);

extern mxArray * mlfSign(mxArray *in1);

extern mxArray * mlfSim(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4, ...);

extern mxArray * mlfSimget(mxArray *in1, mxArray *in2);

extern mxArray * mlfSimset(mxArray *in1, ...);

extern mxArray * mlfSin(mxArray *in1);

extern mxArray * mlfSingle(mxArray *in1);

extern mxArray * mlfSinh(mxArray *in1);

extern mxArray * mlfSize(mlfVarargoutList *varargout, mxArray *in1, mxArray *in2);

extern mxArray * mlfSize2d(mxArray **out1, mxArray *in1, mxArray *in2);

extern void mlfSldebug(mxArray *in1);

extern mxArray * mlfSparse(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4, mxArray *in5, mxArray *in6);

extern mxArray * mlfSparsfun(mxArray **out1, mxArray **out2, mxArray **out3, mxArray **out4, mxArray *in1, ...);

extern mxArray * mlfSprintf(mxArray **out1, mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfSqrt(mxArray *in1);

extern mxArray * mlfSscanf(mxArray **out1, mxArray **out2, mxArray **out3, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfStrrep(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfStrcmp(mxArray *in1, mxArray *in2);

extern mxArray * mlfStrcmpi(mxArray *in1, mxArray *in2);

extern mxArray * mlfStrncmp(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfStrncmpi(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfStruct(mxArray *in1, ...);

extern mxArray * mlfStruct2cell(mxArray *in1);

extern mxArray * mlfSubsasgn(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfSubsindex(mxArray *in1);

extern mxArray * mlfSubsref(mxArray *in1, mxArray *in2);

extern mxArray * mlfSum(mxArray *in1, mxArray *in2);

extern void mlfSuperiorto(mxArray *in1, ...);

extern mxArray * mlfSvd(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2);

extern mxArray * mlfSystem_dependent(mxArray *in1, ...);

extern mxArray * mlfTan(mxArray *in1);

extern mxArray * mlfTanh(mxArray *in1);

extern mxArray * mlfTimes(mxArray *in1, mxArray *in2);

extern mxArray * mlfTranspose(mxArray *in1);

extern mxArray * mlfTrmginput(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfTril(mxArray *in1, mxArray *in2);

extern mxArray * mlfTriu(mxArray *in1, mxArray *in2);

extern void mlfType(mxArray *in1);

extern mxArray * mlfUint8(mxArray *in1);

extern mxArray * mlfUint16(mxArray *in1);

extern mxArray * mlfUint32(mxArray *in1);

extern mxArray * mlfUminus(mxArray *in1);

extern mxArray * mlfUnaryminus(mxArray *in1);

extern mxArray * mlfUplus(mxArray *in1);

extern mxArray * mlfUpper(mxArray *in1);

extern mxArray * mlfUnix(mxArray **out1, mxArray *in1);

extern mxArray * mlfVersion(mxArray **out1);

extern mxArray * mlfVertcat(mxArray *in1, ...);

extern mxArray * mlfVms(mxArray **out1, mxArray *in1);

extern mxArray * mlfWarning(mxArray **out1, mxArray *in1);

extern mxArray * mlfWhich(mxArray *in1, ...);

extern mxArray * mlfWho(mxArray *in1, ...);

extern mxArray * mlfWhos(mxArray *in1, ...);

extern mxArray * mlfWhat(mxArray *in1);

extern mxArray * mlfXlate(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfZeros(mxArray *in1, ...);

extern void mlx_colonobj(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlx_license_checkout(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAbs(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAcos(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAcosh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAdd_block(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAdd_line(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAll(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAnd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAny(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxApplescript(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAsin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAsinh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAssignin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAtan(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAtanh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxAtan2(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBalance(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitand(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitcmp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitget(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitset(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitshift(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitor(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxBitxor(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCallstats(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCeil(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCell(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCell2struct(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxChar(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxChdir(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxChol(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCholinc(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCholupdate(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxClassName(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxClc(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxClock(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxClose_system(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxColon(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxComputer(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxConj(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxConv2(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCos(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCtranspose(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCosh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCumprod(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCumsum(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxCputime(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbclear(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbdown(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbquit(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbstack(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbstatus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbstep(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbstop(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbtype(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDbup(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDelete_block(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDelete_line(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDet(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDiag(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDiary(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDiff(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDir(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDisp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDongarra(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDouble(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxDos(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEcho(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEdt(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEnd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEig(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEps(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEq(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxError(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxErrorstat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxErrortrap(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEvalin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxExit(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxExp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxExpm(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxEye(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFclose(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFeature(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFieldnames(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFields(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFeof(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFerror(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFft(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFftn(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFgets(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFilter(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFind(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFindstr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFinite(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFix(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFloor(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFlops(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFormat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFopen(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFprintf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFread(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFschange(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFscanf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFseek(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFtell(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFull(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxFwrite(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxGe(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxGet_param(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxGetenv(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxGetfield(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxGt(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHcreate(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHardcopy(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHelp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHome(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHess(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHorzcat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxHregister(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxImag(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInferiorto(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInmem(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInput(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInputname(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInt8(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInt16(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInt32(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxInv(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsa(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsequal(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsempty(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsfinite(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsglobal(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsieee(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsjava(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIssparse(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIscell(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIschar(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIslogical(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsstr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsstudent(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsinf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsletter(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsnan(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsreal(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxIsspace(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxJava(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxJava_method(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxJava_object(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxKeyboard(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLastwarn(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLength(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLdivide(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLe(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLinmod(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLog(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLog2(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLogical(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLookfor(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLower(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLt(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLtifr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLtitr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLu(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxLuinc(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMacprint(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMactools(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMagic(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMax(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMethods(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMexext(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMfilename(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMfile2struct(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMinus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMislocked(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMlock(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMldivide(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMpower(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMrdivide(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMtimes(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMore(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxMunlock(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNan(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNdims(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNe(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNeq(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNew_system(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNorm(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxNot(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxOnes(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxOpen_system(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxOr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxOverload(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPack(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPause(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPfile(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPermute(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPi(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPlus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPow2(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxProd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxPower(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxQr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxQrupdate(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxQuit(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxQz(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRand(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRandn(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRcond(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRdivide(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxReal(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRealmax(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRealmin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRem(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxReshape(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxRound(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSchur(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSetfield(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSet_param(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSetstr(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSign(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSim(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSimget(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSimset(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSin(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSingle(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSinh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSize(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSize2d(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSldebug(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSparse(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSparsfun(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSprintf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSqrt(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSscanf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrrep(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrcmp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrcmpi(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrncmp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrncmpi(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStruct(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStruct2cell(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsasgn(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsindex(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsref(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSum(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSuperiorto(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSvd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSystem_dependent(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTan(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTanh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTimes(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTranspose(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTrmginput(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTril(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTriu(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxType(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint8(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint16(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint32(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUminus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUnaryminus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUplus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUpper(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUnix(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVersion(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVertcat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVms(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWarning(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhich(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWho(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhos(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxXlate(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxZeros(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void *mclMalloc(size_t s);

extern void *mclCalloc(size_t c, size_t s);

extern void *mclRealloc(void *p, size_t s);



#ifdef mxMalloc
#undef mxMalloc
#endif
#define mxMalloc mclMalloc

#ifdef mxCalloc
#undef mxCalloc
#endif
#define mxCalloc mclCalloc

#ifdef mxRealloc
#undef mxRealloc
#endif
#define mxRealloc mclRealloc


extern int mclUnshareArray(mxArray *pa, int level);


#ifdef mxUnshareArray
#undef mxUnshareArray
#endif
#define mxUnshareArray mclUnshareArray

extern mxArray *mclCreateCellArray(int ndim, const int *dims);


#ifdef mxCreateCellArray
#undef mxCreateCellArray
#endif
#define mxCreateCellArray mclCreateCellAray

extern mxArray *mclCreateCharMatrixFromStrings(int m, const char **str);


#ifdef mxCreateCharMatrixFromStrings
#undef mxCreateCharMatrixFromStrings
#endif
#define mxCreateCharMatrixFromStrings mclCreateCharMatrixFromStrings

extern mxArray *mclCreateDoubleMatrix(int m, int n, mxComplexity ComplexFlag);


#ifdef mxCreateDoubleMatrix
#undef mxCreateDoubleMatrix
#endif
#define mxCreateDoubleMatrix mclCreateDoubleMatrix

extern mxArray *mclCreateNumericArray(int ndim, const int *dims, 
                                      mxClassID clsid, mxComplexity ComplexFlag);


#ifdef mxCreateNumericArray
#undef mxCreateNumericArray
#endif
#define mxCreateNumericArray mclCreateNumericArray

extern mxArray *mclCreateSparse(int m, int n, int nzmax, 
                                mxComplexity ComplexFlag);


#ifdef mxCreateSparse
#undef mxCreateSparse
#endif
#define mxCreateSparse mclCreateSparse

extern mxArray *mclCreateString(const char *str);


#ifdef mxCreateString
#undef mxCreateString
#endif
#define mxCreateString mclCreateString

extern mxArray *mclCreateStructArray(int ndim, const int *dims, int nfields,
                                    const char **field_names);


#ifdef mxCreateStructArray
#undef mxCreateStructArray
#endif
#define mxCreateStructArray mclCreateStructArray

extern mxArray *mclCreateStructMatrix(int m, int n, int nfields, 
                                      const char **field_names);


#ifdef mxCreateStructMatrix
#undef mxCreateStructMatrix
#endif
#define mxCreateStructMatrix mclCreateStructMatrix

extern mxArray *mclDuplicateArray(const mxArray *in);


#ifdef mxDuplicateArray
#undef mxDuplicateArray
#endif
#define mxDuplicateArray mclDuplicateArray

extern mxArray *mclGetCell(const mxArray *array_ptr, int index);


#ifdef mxGetCell
#undef mxGetCell
#endif
#define mxGetCell mclGetCell

extern void *mclGetData(const mxArray *array_ptr);


#ifdef mxGetData
#undef mxGetData
#endif
#define mxGetData mclGetData

extern mxArray *mclGetField(const mxArray *array_ptr, int index, 
                            const char *field_name);


#ifdef mxGetField
#undef mxGetField
#endif
#define mxGetField mclGetField

extern mxArray *mclGetFieldByNumber(const mxArray *array_ptr, int index, 
                                   int field_number);


#ifdef mxGetFieldByNumber
#undef mxGetFieldByNumber
#endif
#define mxGetFieldByNumber mclGetFieldByNumber

extern void *mclGetImagData(const mxArray *array_ptr);


#ifdef mxGetImagData
#undef mxGetImagData
#endif
#define mxGetImagData mclGetImagData

extern int *mclGetIr(const mxArray *array_ptr);


#ifdef mxGetIr
#undef mxGetIr
#endif
#define mxGetIr mclGetIr

extern int *mclGetJc(const mxArray *array_ptr);


#ifdef mxGetJc
#undef mxGetJc
#endif
#define mxGetJc mclGetJc

extern double *mclGetPr(const mxArray *array_ptr);


#ifdef mxGetPr
#undef mxGetPr
#endif
#define mxGetPr mclGetPr

extern double *mclGetPi(const mxArray *array_ptr);


#ifdef mxGetPi
#undef mxGetPi
#endif
#define mxGetPi mclGetPi

extern void mclSetCell(mxArray *array_ptr, int index, mxArray *value);


#ifdef mxSetCell
#undef mxSetCell
#endif
#define mxSetCell mclSetCell

extern void mclSetData(mxArray *array_ptr, void *data_ptr);


#ifdef mxSetData
#undef mxSetData
#endif
#define mxSetData mclSetData

extern int mclSetDimensions(mxArray *array_ptr, const int *dims, int ndims);


#ifdef mxSetDimensions
#undef mxSetDimensions
#endif
#define mxSetDimensions mclSetDimensions

extern void mclSetField(mxArray *array_ptr, int index, 
                        const char *field_name, mxArray *value);


#ifdef mxSetField
#undef mxSetField
#endif
#define mxSetField mclSetField

extern void mclSetFieldByNumber(mxArray *array_ptr, int index, 
                               int field_number, mxArray *value);


#ifdef mxSetFieldByNumber
#undef mxSetFieldByNumber
#endif
#define mxSetFieldByNumber mclSetFieldByNumber

extern void mclSetImagData(mxArray *array_ptr, void *pi);


#ifdef mxSetImagData
#undef mxSetImagData
#endif
#define mxSetImagData mclSetImagData

extern void mclSetIr(mxArray *array_ptr, int *ir);


#ifdef mxSetIr
#undef mxSetIr
#endif
#define mxSetIr mclSetIr

extern void mclSetJc(mxArray *array_ptr, int *jc);


#ifdef mxSetJc
#undef mxSetJc
#endif
#define mxSetJc mclSetJc

extern void mclSetPi(mxArray *array_ptr, double *pi);


#ifdef mxSetPi
#undef mxSetPi
#endif
#define mxSetPi mclSetPi

extern void mclSetPr(mxArray *array_ptr, double *pr);


#ifdef mxSetPr
#undef mxSetPr
#endif
#define mxSetPr mclSetPr

extern mxArray *mclCreateSharedCopy(const mxArray *pa); 


#ifdef mxCreateSharedCopy
#undef mxCreateSharedCopy
#endif
#define mxCreateSharedCopy mclCreateSharedCopy


typedef struct mclGlobalTableEntry_Tag
{
    const char *name;             /* The name of the global */
    mxArray    **variable;        /* A pointer to the variable */ 
} mclGlobalTableEntry;



/*
 * This function imports the globals from the Matlab workspace into
 * the Compiler 2.0 generated global variables
 */
   
extern void mclImportGlobal( size_t size, mclGlobalTableEntry *gtab );


extern void mclExportGlobal( size_t size, mclGlobalTableEntry *gtab );


extern void mclFevalExecMATLAB(int	nlhs,			/* number of expected outputs */
                        mxArray	*plhs[],		/* pointer array to outputs */
                        int	nrhs,			/* number of inputs */
                        mxArray	*prhs[],		/* pointer array to inputs */
                        const char	*fcn_name       /* function name */
                        );


extern mxArray * mclFevalCallMATLAB(mlfVarargoutList *varargout,
                               const char *name, ...);


extern int mclSupportedDataTypes(int nrhs, mxArray **prhs);

#ifdef __cplusplus
    }	/* extern "C" */
#endif

#endif /* libmatlb_h */
