const char *Attr2StringMalloc(const IPAttributeStruct *Attr,
                                  int DataFileFormat)

    const char *Attr2StringToData(const IPAttributeStruct *Attr,
                                  int DataFileFormat,
                                  char *Str)

    IPAttributeStruct *AttrCopyAttributes(const IPAttributeStruct *Src)

    IPAttributeStruct *AttrCopyAttributes2(const IPAttributeStruct *Src,
                                           int AllAttrs)

    IPAttributeStruct *AttrCopyOneAttribute(const IPAttributeStruct *Src)

    IPAttributeStruct *AttrCopyOneAttribute2(const IPAttributeStruct *Src,
                                             int AllAttr)

    const char **AttrCopyValidAttrNameList(const char **AttrNames)

    IPAttributeStruct *AttrFindAttribute(const IPAttributeStruct *Attrs,
                                         const char *Name)

    IPAttributeStruct *AttrFindAttributeHashNum(const IPAttributeStruct *Attrs,
                                                IPAttrNumType AttrHashNum)

    void AttrFreeAttributes(IPAttributeStruct **Attrs)

    void AttrFreeOneAttribute(IPAttributeStruct **Attrs, const char *Name)

    IPAttrNumType AttrGetAttribHashNumber(const char *AttribName)

    const char *AttrGetAttribName(const IPAttributeStruct *Attr)

    void AttrGetIndexColor(int Color, int *Red, int *Green, int *Blue)

    int AttrGetIntAttrib(const IPAttributeStruct *Attrs, const char *Name)

    int AttrGetIntAttrib2(const IPAttributeStruct *Attrs, IPAttrNumType AttrNum)

    IPAttributeStruct *AttrGetLastAttr(IPAttributeStruct *AList)

    IPAttributeStruct *AttrGetPrevAttr(IPAttributeStruct *AList,
                                       const IPAttributeStruct *A)

    VoidPtr AttrGetPtrAttrib(const IPAttributeStruct *Attrs, const char *Name)

    VoidPtr AttrGetPtrAttrib2(const IPAttributeStruct *Attrs,
                              IPAttrNumType AttrNum)

    int AttrGetRGBColor2(const IPAttributeStruct *Attrs,
                         const char *Name,
                         int *Red,
                         int *Green,
                         int *Blue)

    int AttrGetRGBDoubleColor(const IPAttributeStruct *Attrs,
                              double *Red,
                              double *Green,
                              double *Blue)

    IrtRType AttrGetRealAttrib(const IPAttributeStruct *Attrs, const char *Name)

    IrtRType AttrGetRealAttrib2(const IPAttributeStruct *Attrs,
                                IPAttrNumType AttrNum)

    IrtRType *AttrGetRealPtrAttrib(const IPAttributeStruct *Attrs,
                                   const char *Name)

    IrtRType *AttrGetRealPtrAttrib2(const IPAttributeStruct *Attrs,
                                    IPAttrNumType AttrNum)

    VoidPtr AttrGetRefPtrAttrib(const IPAttributeStruct *Attrs, const char *Name)

    VoidPtr AttrGetRefPtrAttrib2(const IPAttributeStruct *Attrs,
                                 IPAttrNumType AttrNum)

    const char *AttrGetStrAttrib(const IPAttributeStruct *Attrs, const char *Name)

    const char *AttrGetStrAttrib2(const IPAttributeStruct *Attrs,
                                  IPAttrNumType AttrNum)

    float *AttrGetUVAttrib(const IPAttributeStruct *Attrs, const char *Name)

    float *AttrGetUVAttrib2(const IPAttributeStruct *Attrs, IPAttrNumType AttrNum)

    const IPAttrIDType *AttrIDCopyValidAttrIDList(const IPAttrIDType *AttrIDs,
                                                  int *IsValidList)

    IPAttributeStruct *AttrIDFindAttribute(const IPAttributeStruct *Attrs,
                                           IPAttrIDType AttrID)

    void AttrIDFreeOneAttribute(IPAttributeStruct **Attrs, IPAttrIDType AttrID)

    IPAttrIDType AttrIDGetAttribID(const char *AttribName)

    int AttrIDGetColor(const IPAttributeStruct *Attrs)

    int AttrIDGetIntAttrib(const IPAttributeStruct *Attrs,
                           IPAttrIDType AttribID)

    VoidPtr AttrIDGetPtrAttrib(const IPAttributeStruct *Attrs,
                               IPAttrIDType AttribID)

    int AttrIDGetRGBColor(const IPAttributeStruct *Attrs,
                          int *Red,
                          int *Green,
                          int *Blue)

    int AttrIDGetRGBColor2(const IPAttributeStruct *Attrs,
                           IPAttrIDType AttrID,
                           int *Red,
                           int *Green,
                           int *Blue)

    int AttrIDGetRGBDoubleColor(const IPAttributeStruct *Attrs,
                                double *Red,
                                double *Green,
                                double *Blue)

    IrtRType AttrIDGetRealAttrib(const IPAttributeStruct *Attrs,
                                 IPAttrIDType AttribID)

    IrtRType *AttrIDGetRealPtrAttrib(const IPAttributeStruct *Attrs,
                                     IPAttrIDType AttribID)

    VoidPtr AttrIDGetRefPtrAttrib(const IPAttributeStruct *Attrs,
                                  IPAttrIDType AttribID)

    const char *AttrIDGetStrAttrib(const IPAttributeStruct *Attrs,
                                   IPAttrIDType AttribID)

    float *AttrIDGetUVAttrib(const IPAttributeStruct *Attrs,
                             IPAttrIDType AttribID)

    IrtRType AttrIDGetWidth(const IPAttributeStruct *Attrs)

    void AttrIDRemoveOneAttribute(IPAttributeStruct **Attrs, IPAttrIDType AttrID)

    void AttrIDSetColor(IPAttributeStruct **Attrs, int Color)

    void AttrIDSetIntAttrib(IPAttributeStruct **Attrs,
                            IPAttrIDType AttribID,
                            int Data)

    void AttrIDSetPtrAttrib(IPAttributeStruct **Attrs,
                            IPAttrIDType AttribID,
                            VoidPtr Data)

    void AttrIDSetRGBColor(IPAttributeStruct **Attrs, int Red, int Green, int Blue)

    void AttrIDSetRGBDoubleColor(IPAttributeStruct **Attrs,
                                 double Red,
                                 double Green,
                                 double Blue)

    void AttrIDSetRealAttrib(IPAttributeStruct **Attrs,
                             IPAttrIDType AttribID,
                             IrtRType Data)

    void AttrIDSetRealPtrAttrib(IPAttributeStruct **Attrs,
                                IPAttrIDType AttribID,
                                IrtRType *Data,
                                int DataLen)

    void AttrIDSetRefPtrAttrib(IPAttributeStruct **Attrs,
                               IPAttrIDType AttribID,
                               VoidPtr Data)

    void AttrIDSetStrAttrib(IPAttributeStruct **Attrs,
                            IPAttrIDType AttribID,
                            const char *Data)

    void AttrIDSetUVAttrib(IPAttributeStruct **Attrs,
                           IPAttrIDType AttribID,
                           IrtRType U,
                           IrtRType V)

    void AttrIDSetWidth(IPAttributeStruct **Attrs, IrtRType Width)

    void AttrInitHashTbl(void)

    IPAttributeStruct *AttrMergeAttributes(IPAttributeStruct *Orig,
                                           const IPAttributeStruct *Src,
                                           int Replace)

    IPAttributeStruct *AttrReverseAttributes(IPAttributeStruct *Attr)

    void AttrSetIntAttrib(IPAttributeStruct **Attrs, const char *Name, int Data)

    void AttrSetIntAttrib2(IPAttributeStruct **Attrs,
                           IPAttrNumType AttribNum,
                           int Data)

    void AttrSetPtrAttrib(IPAttributeStruct **Attrs,
                          const char *Name,
                          VoidPtr Data)

    void AttrSetPtrAttrib2(IPAttributeStruct **Attrs,
                           IPAttrNumType AttribNum,
                           VoidPtr Data)

    void AttrSetRGBDoubleColor(IPAttributeStruct **Attrs,
                               double Red,
                               double Green,
                               double Blue)

    void AttrSetRealAttrib(IPAttributeStruct **Attrs,
                           const char *Name,
                           IrtRType Data)

    void AttrSetRealAttrib2(IPAttributeStruct **Attrs,
                            IPAttrNumType AttribNum,
                            IrtRType Data)

    void AttrSetRealPtrAttrib(IPAttributeStruct **Attrs,
                              const char *Name,
                              IrtRType *Data,
                              int DataLen)

    void AttrSetRealPtrAttrib2(IPAttributeStruct **Attrs,
                               IPAttrNumType AttribNum,
                               IrtRType *Data,
                               int DataLen)

    void AttrSetRefPtrAttrib(IPAttributeStruct **Attrs,
                             const char *Name,
                             VoidPtr Data)

    void AttrSetRefPtrAttrib2(IPAttributeStruct **Attrs,
                              IPAttrNumType AttribNum,
                              VoidPtr Data)

    void AttrSetStrAttrib(IPAttributeStruct **Attrs,
                          const char *Name,
                          const char *Data)

    void AttrSetStrAttrib2(IPAttributeStruct **Attrs,
                           IPAttrNumType AttribNum,
                           const char *Data)

    void AttrSetUVAttrib(IPAttributeStruct **Attrs,
                         const char *Name,
                         IrtRType U,
                         IrtRType V)

    void AttrSetUVAttrib2(IPAttributeStruct **Attrs,
                          IPAttrNumType AttribNum,
                          IrtRType U,
                          IrtRType V)

    const IPAttributeStruct *AttrTraceAttributes(
                                             const IPAttributeStruct *TraceAttrs,
                                             const IPAttributeStruct *FirstAttrs)

    void E2TFreeNodetree(IritE2TExprNodeStruct *Root)

    int GAGetArgs(int va_alist, ...)

    void GAPrintErrMsg(int Error)

    void GAPrintHowTo(const char *CtrlStr)

    char *GAStringErrMsg(int Error, char *OutStr)

    char *GAStringHowTo(const char *CtrlStr, char *OutStr)

    IrtRType IritApproxStrStrMatch(const char *Str1,
                                   const char *Str2,
                                   int IgnoreCase)

    wchar_t *IritAscii2WChar(const char *Str)

    IrtRType IritCPUTime(int Reset)

    const char *IritConfig(const char *PrgmName,
                           const IritConfigStruct *SetUp,
                           int NumVar,
                           char *FoundName)

    void IritConfigInitState(void)

    void IritConfigPrint(const IritConfigStruct *SetUp, int NumVar)

    int IritConfigSave(const char *FileName,
                       const IritConfigStruct *SetUp,
                       int NumVar)

    void IritDynMemoryDbgCheckMark(IrtRType *Start,
                                   IrtRType *KeepStackStep,
                                   IrtRType *TrackAllocID)

    void IritDynMemoryDbgInitTest(void)

    void IritDynMemoryDbgInitTest2(int DebugMalloc, int DebugSearchAllocID)

    void IritDynMemoryDbgMallocSearchID(int ID)

    void *IritDynMemoryDbgNoReport(void *p)

    void IritDynMemoryDbgTestAll(void)

    IrtRType IritE2Expr2TreeDefaultFetchParamValue(MiscExprTreeGenInfoStruct *GI,
                                                   const char *SData)

    IritE2TExprNodeParamFuncType IritE2Expr2TreeSetFetchParamValueFunc(
                                MiscExprTreeGenInfoStruct *GI,
                                IritE2TExprNodeParamFuncType FetchParamValueFunc)

    int IritE2TCmpTree(const IritE2TExprNodeStruct *Root1,
                       const IritE2TExprNodeStruct *Root2)

    IritE2TExprNodeStruct *IritE2TCopyTree(const IritE2TExprNodeStruct *Root)

    int IritE2TDerivError(MiscExprTreeGenInfoStruct *GI)

    IritE2TExprNodeStruct *IritE2TDerivTree(MiscExprTreeGenInfoStruct *GI,
                                            const IritE2TExprNodeStruct *Root,
                                            int Param)

    IrtRType IritE2TEvalTree(MiscExprTreeGenInfoStruct *GI,
                             const IritE2TExprNodeStruct *Root)

    IritE2TExprNodeStruct *IritE2TExpr2Tree(MiscExprTreeGenInfoStruct *GI,
                                            const char s[])

    void IritE2TExpr2TreeFree(MiscExprTreeGenInfoStruct *GI)

    MiscExprTreeGenInfoStruct *IritE2TExpr2TreeInit()

    void IritE2TFreeTree(IritE2TExprNodeStruct *Root)

    int IritE2TParamInTree(const IritE2TExprNodeStruct *Root,
                           const char *ParamName)

    int IritE2TParseError(MiscExprTreeGenInfoStruct *GI)

    void IritE2TPrintTree(const IritE2TExprNodeStruct *Root, char *Str)

    void IritE2TSetParamValue(MiscExprTreeGenInfoStruct *GI,
                              IrtRType Value,
                              int Index)

    void IritEmulatePthreadMutexLock(IRIT_MUTEX *Mx)

    void IritEmulatePthreadMutexUnLock(IRIT_MUTEX Mx)

    void IritFatalError(const char *Msg)

    void IritFatalErrorPrintf(const char *va_alist, ...)

    void IritFree(VoidPtr p)

    void IritFree2UnixFree(void *p)

    int IritGaussJordan(IrtRType *A, IrtRType *B, unsigned N, unsigned M)

    IritHashTableStruct *IritHashTableCreate(IrtRType MinKeyVal,
                                             IrtRType MaxKeyVal,
                                             IrtRType KeyEps,
                                             int VecSize)

    VoidPtr IritHashTableFind(IritHashTableStruct *IHT,
                              VoidPtr Data,
                              IritHashCmpFuncType HashCmpFunc,
                              IrtRType Key)

    void IritHashTableFree(IritHashTableStruct *IHT)

    int IritHashTableInsert(IritHashTableStruct *IHT,
                            VoidPtr Data,
                            IritHashCmpFuncType HashCmpFunc,
                            IrtRType Key,
                            int RplcSame)

    int IritHashTableRemove(IritHashTableStruct *IHT,
                            VoidPtr Data,
                            IritHashCmpFuncType HashCmpFunc,
                            IrtRType Key)

    void IritImgPrcssAppFunOnLine(IritImgPrcssImgStruct *Image,
                                  int X0,
                                  int Y0,
                                  int X1,
                                  int Y1,
                                  IritImgPrcssFunctionOnPixel F,
                                  void *Data)

    IritImgPrcssImgStruct *IritImgPrcssBiSobel(const IritImgPrcssImgStruct *Image)

    IritImgPrcssImgStruct *IritImgPrcssConv3(const IritImgPrcssImgStruct *Image,
                                             float Filter[9],
                                             int Normalize)

    IritImgPrcssImgStruct *IritImgPrcssCopyImg(const IritImgPrcssImgStruct *Image)

    IritImgPrcssImgStruct *IritImgPrcssCreateBlkImg(unsigned int Height,
                                                    unsigned int Width)

    IritImgPrcssImgStruct *IritImgPrcssCreateImg(unsigned int Height,
                                                 unsigned int Width,
                                                 float *Data)

    IritImgPrcssImgStruct *IritImgPrcssCreateWhiteImg(unsigned int Height,
                                                      unsigned int Width)

    void IritImgPrcssDeleteImg(IritImgPrcssImgStruct *Image)

    IritImgPrcssImgStruct *IritImgPrcssDetectEdges(const IritImgPrcssImgStruct
                                                                           *Image,
                                                   int BlurAmount)

    IritImgPrcssImgStruct *IritImgPrcssGaussianBlur(const IritImgPrcssImgStruct
                                                                           *Image)

    IritImgPrcssImgStruct *
                     IritImgPrcssGaussianBlurMult(IritImgPrcssImgStruct *Image,
                                                  int Amount)

    int IritImgPrcssGetPixelVal(const IritImgPrcssImgStruct *Image,
                                unsigned int i,
                                unsigned int j,
                                float Color[4])

    IritImgPrcssImgStruct *IritImgPrcssInvert(const IritImgPrcssImgStruct *Image)

    IritImgPrcssImgStruct *IritImgPrcssReadImg(const char *Path)

    int IritImgPrcssSetPixelVal(IritImgPrcssImgStruct *Image,
                                 unsigned int i,
                                 unsigned int j,
                                 const float color[4])

    IritImgPrcssImgStruct *IritImgPrcssSharpen(const IritImgPrcssImgStruct *Image)

    IritImgPrcssImgStruct *IritImgPrcssToGrayScale(const IritImgPrcssImgStruct
                                                                           *Image)

    void IritImgPrcssWriteImg(IritImgPrcssImgStruct *Image, const char *SavePath)

    void IritInformationMsg(const char *Msg)

    void IritInformationMsgPrintf(const char *va_alist, ...)

    void IritInformationWMsg(const wchar_t *Msg)

    void IritIntrvlArithAbs(const IritIntrvlArithStruct *A,
                            IritIntrvlArithStruct *Result)

    void IritIntrvlArithAdd(const IritIntrvlArithStruct *A,
                            const IritIntrvlArithStruct *B,
                            IritIntrvlArithStruct *Result)

    void IritIntrvlArithDiv(const IritIntrvlArithStruct *A,
                            const IritIntrvlArithStruct *B,
                            IritIntrvlArithStruct *Result)

    void IritIntrvlArithMult(const IritIntrvlArithStruct *A,
                             const IritIntrvlArithStruct *B,
                             IritIntrvlArithStruct *Result)

    void IritIntrvlArithMultScalar(const IritIntrvlArithStruct *A,
                                   IrtRType Val,
                                   IritIntrvlArithStruct *Result)

    void IritIntrvlArithSqrt(const IritIntrvlArithStruct *A,
                             IritIntrvlArithStruct *Result)

    void IritIntrvlArithSub(const IritIntrvlArithStruct *A,
                            const IritIntrvlArithStruct *B,
                            IritIntrvlArithStruct *Result)

    void IritIntrvlArithUnion(const IritIntrvlArithStruct *A,
                              const IritIntrvlArithStruct *B,
                              IritIntrvlArithStruct *Result)

    void IritIntrvlArithVAdd(const IritIntrvlArithStruct *A,
                             const IritIntrvlArithStruct *B,
                             IritIntrvlArithStruct *Result)

    void IritIntrvlArithVCross(const IritIntrvlArithStruct *A,
                               const IritIntrvlArithStruct *B,
                               IritIntrvlArithStruct *Result)

    void IritIntrvlArithVDot(const IritIntrvlArithStruct *A,
                             const IritIntrvlArithStruct *B,
                             IritIntrvlArithStruct *Result)

    void IritIntrvlArithVFromCone(const IrtRType *Dir,
                                  IrtRType Angle,
                                  IritIntrvlArithStruct *Result)

    void IritIntrvlArithVMultScalar(const IritIntrvlArithStruct *A,
                                    IrtRType Val,
                                    IritIntrvlArithStruct *Result)

    void IritIntrvlArithVToCone(const IritIntrvlArithStruct *IntervalV,
                                IrtRType *Dir,
                                IrtRType *Angle)

    void IritIntrvlArithVToSphere(const IritIntrvlArithStruct *IntervalV,
                                  IrtRType *Center,
                                  IrtRType *Radius)

    IrtRType IritLevenMarMin(IrtRType **X,
                             IrtRType Y[],
                             IrtRType Sigma[],
                             unsigned NumberOfDataElements,
                             IrtRType ModelParams[],
                             IritLevenEvalFuncType *ShapeFunc,
                             IritLevenNumerProtectionFuncType *ProtectionFunc,
                             IritLevenIsModelValidFuncType *ModelValidatorFunc,
                             unsigned NumberOfModelParams,
                             IrtRType Tolerance)

    IrtRType IritLevenMarMinSig1(IrtRType **X,
                                 IrtRType Y[],
                                 unsigned NumberOfDataElements,
                                 IrtRType ModelParams[],
                                 IritLevenEvalFuncType *ShapeFunc,
                                 IritLevenNumerProtectionFuncType *ProtectionFunc,
                                 IritLevenIsModelValidFuncType *ModelValidatorFunc,
                                 unsigned NumberOfModelParams,
                                 IrtRType Tolerance)

    unsigned IritLevenMarSetMaxIterations(unsigned NewVal)

    int IritLineHasCntrlChar(const char *Line)

    VoidPtr IritMalloc(unsigned Size,
                       const char *ObjType,
                       const char *FileName,
                       int LineNum)

    void IritPQCompFunc(IritPQCompFuncType NewCompFunc)

    VoidPtr IritPQDelete(IritPriorQue **PQ, VoidPtr OldItem)

    int IritPQEmpty(IritPriorQue *PQ)

    VoidPtr IritPQFind(IritPriorQue *PQ, VoidPtr OldItem)

    VoidPtr IritPQFirst(IritPriorQue **PQ, int Delete)

    void IritPQFree(IritPriorQue *PQ, int FreeItem)

    void IritPQFreeFunc(IritPriorQue *PQ, void (*FreeFunc)(VoidPtr))

    void IritPQInit(IritPriorQue **PQ)

    VoidPtr IritPQInsert(IritPriorQue **PQ, VoidPtr NewItem)

    VoidPtr IritPQNext(IritPriorQue *PQ, VoidPtr CmpItem, VoidPtr LargerThan)

    void IritPQPrint(IritPriorQue *PQ, void (*PrintFunc)(VoidPtr))

    int IritPQSize(IritPriorQue *PQ)

    IrtRType IritPseudoRandom()

    void IritPseudoRandomInit(unsigned int Seed)

    int IritQRFactorization(IrtRType *A,
                            int n,
                            int m,
                            IrtRType *Q,
                            IrtRType *R)

    int IritQRUnderdetermined(IrtRType *A,
                              IrtRType *x,
                              const IrtRType *b,
                              int m,
                              int n,
                              void **QRCache)

    int IritQRUnderdetermined2(IrtRType *A,
                               IrtRType *x,
                               const IrtRType *b,
                               int m,
                               int n)

    void IritRLAdd(VoidPtr RLC, IrtRType l, IrtRType r, int Attr)

    void IritRLDelete(VoidPtr RLC)

    int *IritRLFindCyclicCover(VoidPtr RLC, IrtRType Tol)

    VoidPtr IritRLNew(void)

    int IritRLSetGaurdiansNumber(int g)

    IrtRType IritRandom(IrtRType Min, IrtRType Max)

    void IritRandomInit(long Seed)

    char *IritRealTimeDate(char *StrTime)

    VoidPtr IritRealloc(VoidPtr p, unsigned OldSize, unsigned NewSize)

    int IritSearch2DFindElem(VoidPtr S2D,
                             IrtRType XKey,
                             IrtRType YKey,
                             VoidPtr Data)

    void IritSearch2DFree(VoidPtr S2D)

    VoidPtr IritSearch2DInit(IrtRType XMin,
                             IrtRType XMax,
                             IrtRType YMin,
                             IrtRType YMax,
                             IrtRType Tol,
                             int DataSize)

    void IritSearch2DInsertElem(VoidPtr S2D,
                                IrtRType XKey,
                                IrtRType YKey,
                                VoidPtr Data)

    IritFatalMsgFuncType IritSetFatalErrorFunc(IritFatalMsgFuncType FatalMsgFunc)

    IritInfoMsgFuncType IritSetInfoMsgFunc(IritInfoMsgFuncType InfoMsgFunc)

    IritInfoWMsgFuncType IritSetInfoWMsgFunc(IritInfoWMsgFuncType InfoWMsgFunc)

    int IritSetIritParallelExec(int Prll)

    IritWarningMsgFuncType IritSetWarningMsgFunc(IritWarningMsgFuncType WrnMsgFunc)

    void IritSleep(int MilliSeconds)

    int IritSolveLowerDiagMatrix(const IrtRType *A,
                                 int n,
                                 const IrtRType *b,
                                 IrtRType *x)

    int IritSolveUpperDiagMatrix(const IrtRType *A,
                                 int n,
                                 const IrtRType *b,
                                 IrtRType *x)

    const char *IritStrIStr(const char *s, const char *Pattern)

    char *IritStrLower(char *s)

    char *IritStrUpper(char *s)

    char *IritStrdup(const char *s)

    char *IritSubstStr(const char *s,
                       const char *Src,
                       const char *Dst,
                       int CaseInsensitive)

    const char *IritTextLocaleInit(void)

    char *IritWChar2Ascii(const wchar_t *Str)

    void IritWarningMsg(const char *Msg)

    void IritWarningMsgPrintf(const char *va_alist, ...)

    IrtImgRGBAPxlStruct *IrtDitherBurkes(IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherFloydSteinberg(
                                          IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherJarvisJudiceNinke(
                                          IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherSierraFirst(
                                         IrtImgRGBAPxlStruct *Image,
                                         int XSize,
                                         int YSize,
                                         int NumColors,
                                         const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherSierraSecond(
                                          IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherSierraThird(
                                          IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtDitherStucki(IrtImgRGBAPxlStruct *Image,
                                         int XSize,
                                         int YSize,
                                         int NumColors,
                                         const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtImgCnvrtRGB2RGBA(const IrtImgPixelStruct *RGBImg,
                                             int XSize,
                                             int YSize)

    IrtImgRGBAPxlStruct *IrtImgDitherImage(IrtImgRGBAPxlStruct *Image,
                                           int XSize,
                                           int YSize,
                                           int DitherSize,
                                           IrtBType ErrorDiffusion,
                                           int NumColors,
                                           const IrtImgRGBAPxlStruct *DitherColors)

    int IrtImgDitherImage2(const char *InputImage,
                           const char *OutputImage,
                           int DitherSize,
                           IrtBType ErrorDiffusion,
                           int NumColors,
                           const IrtImgRGBAPxlStruct *DitherColors)

    int IrtImgDitherImage3(const char *InputImage,
                           const char *OutputImage,
                           int NumColors,
                           const IrtImgRGBAPxlStruct *DitherColors,
                           IrtImgImageDitherType DitherMethod)

    IrtBType *IrtImgDitherImageBW(IrtImgRGBAPxlStruct *Image,
                                  int XSize,
                                  int YSize,
                                  int DitherSize,
                                  IrtBType ErrorDiffusion)

    IrtBType *IrtImgDitherImageBW1(IrtImgPixelStruct *Image,
                                   int XSize,
                                   int YSize,
                                   int DitherSize,
                                   IrtBType ErrorDiffusion)

    IrtImgRGBAPxlStruct *IrtImgDitherImageBW2(IrtImgRGBAPxlStruct *Image,
                                              int XSize,
                                              int YSize,
                                              int DitherSize,
                                              IrtBType ErrorDiffusion)

    IrtImgRGBAPxlStruct *IrtImgDitherImageClr(
                                           IrtImgRGBAPxlStruct *Image,
                                           int XSize,
                                           int YSize,
                                           int DitherSize,
                                           IrtBType ErrorDiffusion,
                                           int NumColors,
                                           const IrtImgRGBAPxlStruct *DitherColors)

    IrtImgRGBAPxlStruct *IrtImgDitherImageClr3(
                                          IrtImgRGBAPxlStruct *Image,
                                          int XSize,
                                          int YSize,
                                          int NumColors,
                                          const IrtImgRGBAPxlStruct *DitherColors,
                                          IrtImgImageDitherType DitherMethod)

    void IrtImgDitherImageClrBatch(const char **ImagePaths,
                                   int NumImages,
                                   const char *OutputFolder,
                                   int NumColors,
                                   const IrtImgRGBAPxlStruct *DitherColors,
                                   IrtImgImageDitherType DitherMethod)

    IrtImgPixelStruct *IrtImgFlipHorizontallyImage(const IrtImgPixelStruct *Img,
                                                   int MaxX,
                                                   int MaxY,
                                                   int Alpha)

    IrtImgPixelStruct *IrtImgFlipVerticallyImage(const IrtImgPixelStruct *Img,
                                                 int MaxX,
                                                 int MaxY,
                                                 int Alpha)

    IrtImgPixelStruct *IrtImgFlipXYImage(const IrtImgPixelStruct *Img,
                                         int MaxX,
                                         int MaxY,
                                         int Alpha)

    int IrtImgGetImageSize(const char *ImageFileName,
                           int *Width,
                           int *Height)

    IrtImgPixelStruct *IrtImgNegateImage(const IrtImgPixelStruct *InImage,
                                         int MaxX,
                                         int MaxY)

    int IrtImgParsePTextureString(const char *PTexture,
                                  char *FName,
                                  IrtRType *Scale,
                                  int *Flip,
                                  int *NewImage)

    int IrtImgParsePTextureString2(const char *PTexture,
                                   char *FName,
                                   IrtRType *Scale,
                                   int *Flip,
                                   int *NewImage,
                                   int *FlipHorizontally,
                                   int *FlipVertically)

    void IrtImgReadClrCache(void)

    void IrtImgReadClrOneImage(const char *ImageName)

    IrtImgPixelStruct *IrtImgReadImage(const char *ImageFileName,
                                       int *MaxX,
                                       int *MaxY,
                                       int *Alpha)

    IrtImgPixelStruct *IrtImgReadImage2(const char *ImageFileName,
                                        int *MaxX,
                                        int *MaxY,
                                        int *Alpha)

    IrtImgPixelStruct *IrtImgReadImage3(const char *ImageFileName,
                                        int *MaxX,
                                        int *MaxY,
                                        int *Alpha)

    int IrtImgReadImageXAlign(int Alignment)

    int IrtImgReadUpdateCache(const char *ImageFileName,
                              int MaxX,
                              int MaxY,
                              int Alpha,
                              IrtBType *Image)

    void IrtImgWriteCloseFile(MiscWriteGenInfoStruct *GI)

    IrtImgImageType IrtImgWriteGetType(const char *ImageType)

    MiscWriteGenInfoStruct *IrtImgWriteOpenFile(const char **argv,
                                                const char *FName,
                                                IrtImgImageType ImageType,
                                                int Alpha,
                                                int XSize,
                                                int YSize)

    void IrtImgWritePutLine(MiscWriteGenInfoStruct *GI,
                            IrtBType *Alpha,
                            IrtImgPixelStruct *Pixels)

    int IrtMovieParsePMovieString(const char *PMovie,
                                  char *FName,
                                  IrtRType *Scale,
                                  int *NewImage,
                                  int *Flip,
                                  int *Restart,
                                  IrtRType *TimeSetup,
                                  int *FlipHorizontally,
                                  int *FlipVertically)

    void IrtMovieReadClrCache(void)

    IrtImgPixelStruct **IrtMovieReadMovie(const char *MovieFileName,
                                          int *MaxX,
                                          int *MaxY,
                                          int *Alpha)

    IrtImgPixelStruct **IrtMovieReadMovie2(const char *MovieFileName,
                                           int *MaxX,
                                           int *MaxY,
                                           int *Alpha)

    IrtImgPixelStruct **IrtMovieReadMovie3(const char *MovieFileName,
                                           int *MaxX,
                                           int *MaxY,
                                           int *Alpha)

    IrtRType Mat2x2Determinant(IrtRType a11,
                               IrtRType a12,
                               IrtRType a21,
                               IrtRType a22)

    IrtRType Mat3x3Determinant(IrtRType a11,
                               IrtRType a12,
                               IrtRType a13,
                               IrtRType a21,
                               IrtRType a22,
                               IrtRType a23,
                               IrtRType a31,
                               IrtRType a32,
                               IrtRType a33)

    void MatAddTwo4by4(IrtHmgnMatType MatRes,
                       IrtHmgnMatType Mat1,
                       IrtHmgnMatType Mat2)

    IrtRType MatDeterminantMatrix(IrtHmgnMatType Mat)

    void MatGenMatRotX(IrtRType CosTeta, IrtRType SinTeta, IrtHmgnMatType Mat)

    void MatGenMatRotX1(IrtRType Teta, IrtHmgnMatType Mat)

    void MatGenMatRotY(IrtRType CosTeta, IrtRType SinTeta, IrtHmgnMatType Mat)

    void MatGenMatRotY1(IrtRType Teta, IrtHmgnMatType Mat)

    void MatGenMatRotZ(IrtRType CosTeta, IrtRType SinTeta, IrtHmgnMatType Mat)

    void MatGenMatRotZ1(IrtRType Teta, IrtHmgnMatType Mat)

    void MatGenMatScale(IrtRType Sx, IrtRType Sy, IrtRType Sz, IrtHmgnMatType Mat)

    void MatGenMatTrans(IrtRType Tx, IrtRType Ty, IrtRType Tz, IrtHmgnMatType Mat)

    void MatGenMatUnifScale(IrtRType Scale, IrtHmgnMatType Mat)

    void MatGenUnitMat(IrtHmgnMatType Mat)

    void MatGnrlAddTwoMat(IrtGnrlMatType MatRes,
                          IrtGnrlMatType Mat1,
                          IrtGnrlMatType Mat2,
                          int n)

    void MatGnrlCopy(IrtGnrlMatType Dst, IrtGnrlMatType Src, int n)

    IrtRType MatGnrlDetMatrix(IrtGnrlMatType M, int n)

    int MatGnrlInverseMatrix(IrtGnrlMatType M, IrtGnrlMatType InvM, int n)

    int MatGnrlIsUnitMatrix(IrtGnrlMatType Mat, IrtRType Eps, int n)

    void MatGnrlMultTwoMat(IrtGnrlMatType MatRes,
                           IrtGnrlMatType Mat1,
                           IrtGnrlMatType Mat2,
                           int n)

    void MatGnrlMultVecbyMat(IrtVecGnrlType VecRes,
                             IrtGnrlMatType Mat,
                             IrtVecGnrlType Vec,
                             int n)

    void MatGnrlMultVecbyMat2(IrtVecGnrlType VecRes,
                              IrtVecGnrlType Vec,
                              IrtGnrlMatType Mat,
                              int n)

    int MatGnrlOrthogonalSubspace(IrtGnrlMatType M, int n)

    void MatGnrlPrintMatrix(IrtGnrlMatType M, int n, FILE *F)

    void MatGnrlScaleMat(IrtGnrlMatType MatRes,
                         IrtGnrlMatType Mat,
                         IrtRType *Scale,
                         int n)

    void MatGnrlSubTwoMat(IrtGnrlMatType MatRes,
                          IrtGnrlMatType Mat1,
                          IrtGnrlMatType Mat2,
                          int n)

    void MatGnrlTranspMatrix(IrtGnrlMatType M, IrtGnrlMatType TranspM, int n)

    void MatGnrlUnitMat(IrtGnrlMatType Mat, int n)

    int MatInverseMatrix(IrtHmgnMatType M, IrtHmgnMatType InvM)

    int MatIsUnitMatrix(IrtHmgnMatType Mat, IrtRType Eps)

    int MatIsWeightAffected(IrtHmgnMatType Mat, IrtRType Eps)

    void MatMultPtby4by4(IrtPtType PtRes,
                         const IrtPtType Pt,
                         IrtHmgnMatType Mat)

    void MatMultTwo4by4(IrtHmgnMatType MatRes,
                        IrtHmgnMatType Mat1,
                        IrtHmgnMatType Mat2)

    void MatMultVecby4by4(IrtVecType VecRes,
                          const IrtVecType Vec,
                          IrtHmgnMatType Mat)

    void MatMultWVecby4by4(IrtRType VRes[4],
                           const IrtRType Vec[4],
                           IrtHmgnMatType Mat)

    void MatRotSclFactorMatrix(IrtHmgnMatType M, IrtHmgnMatType RotSclMat)

    void MatRotateFactorMatrix(IrtHmgnMatType M, IrtHmgnMatType RotMat)

    int MatSameTwo4by4(IrtHmgnMatType Mat1,
                       IrtHmgnMatType Mat2,
                       IrtRType Eps)

    void MatScale4by4(IrtHmgnMatType MatRes,
                      IrtHmgnMatType Mat,
                      const IrtRType *Scale)

    IrtRType MatScaleFactorMatrix(IrtHmgnMatType M)

    IrtRType *MatScaleFactorMatrix2(IrtHmgnMatType M, IrtVecType ScaleVec)

    void MatSubTwo4by4(IrtHmgnMatType MatRes,
                       IrtHmgnMatType Mat1,
                       IrtHmgnMatType Mat2)

    void MatTranslateFactorMatrix(IrtHmgnMatType M, IrtVecType Trans)

    void MatTranspMatrix(IrtHmgnMatType M, IrtHmgnMatType TranspM)

    int *MiscBiPrComputeMinCostRecMatching(const IrtRType *CostMat,
                                           int NumRows,
                                           int NumCols)

    int MiscBiPrWeightedMatchBipartite(const IrtRType **Weight,
                                       IritBiPrWeightedMatchStruct *Match,
                                       int n)

    const char *MiscDescribeError(MiscFatalErrorType ErrorNum)

    void MiscFatalError(MiscFatalErrorType ErrID, char *ErrDesc)

    int MiscHashAddElement(MiscHashPtrType Hash,
                           void *Elem,
                           unsigned long SizeInByte)

    int MiscHashFindElement(MiscHashPtrType Hash,
                            void *Elem,
                            unsigned long SizeInByte)

    void MiscHashFreeHash(MiscHashPtrType Hash)

    long *MiscHashGetElementAuxData(MiscHashPtrType Hash,
                                    void *Elem,
                                    unsigned long SizeInByte)

    MiscHashPtrType MiscHashNewHash(unsigned long Size,
                                    MiscHashFuncType HashFunc,
                                    MiscHashCopyFuncType CopyFunc,
                                    MiscHashFreeFuncType FreeFunc,
                                    MiscHashCompFuncType CompFunc)

    int MiscISCAddPicture(MiscISCCalculatorPtrType Calc, MiscISCPixelType *Picture)

    int MiscISCCalculateExact(MiscISCCalculatorPtrType Calc,
                              int SizeLimit,
                              int **SolutionByIndex,
                              int *SolutionSize,
                              IrtRType *CoverPart)

    int MiscISCCalculateExhaustive(MiscISCCalculatorPtrType Calc,
                                   IrtRType CoverLimit,
                                   int SizeLimit,
                                   int **SolutionByIndex,
                                   int *SolutionSize,
                                   IrtRType *CoverPart)

    int MiscISCCalculateGreedy(MiscISCCalculatorPtrType Calc,
                               int **SolutionByIndex,
                               int *SolutionSize,
                               IrtRType *CoverPart)

    void MiscISCFreeCalculator(MiscISCCalculatorPtrType Calc)

    MiscISCCalculatorPtrType MiscISCNewCalculator(int MaxPictures,
                                                  MiscISCImageSizeType ImageSize,
                                                  MiscISCColorTypeEnum ColorType,
                                                  MiscISCPrintFuncType Print)

    int MiscISCSetImageToCover(MiscISCCalculatorPtrType Calc,
                               MiscISCPixelType *RequiredCover)

    int MiscListAddElement(MiscListPtrType List,
                           void *Elem,
                           unsigned long SizeInByte)

    int MiscListCompLists(MiscListPtrType L1, MiscListPtrType L2)

    int MiscListFindElementInList(MiscListPtrType List,
                                  void *Elem,
                                  unsigned long SizeInByte)

    void MiscListFreeList(MiscListPtrType List)

    void MiscListFreeListIterator(MiscListIteratorPtrType It)

    MiscListIteratorPtrType MiscListGetListIterator(MiscListPtrType List)

    int MiscListIteratorAtEnd(MiscListIteratorPtrType It)

    void *MiscListIteratorFirst(MiscListIteratorPtrType It)

    void *MiscListIteratorNext(MiscListIteratorPtrType It)

    void *MiscListIteratorValue(MiscListIteratorPtrType It)

    MiscListPtrType MiscListNewEmptyList(MiscListCopyFuncType CopyFunc,
                                         MiscListFreeFuncType FreeFunc,
                                         MiscListCompFuncType CompFunc)

    MiscPHashMap MiscPHashMapCreate(int HashSize)

    void MiscPHashMapDelete(MiscPHashMap HMap)

    MiscPHMResult MiscPHashMapGet(MiscPHashMap HMap,
                                  MiscPHashMapKey Key,
                                  MiscPHashMapValue *Value)

    void MiscPHashMapIterate(MiscPHashMap HMap, MiscPHashMapCBFunc CBFunc)

    void MiscPHashMapPrint(MiscPHashMap HMap)

    MiscPHMResult MiscPHashMapRemove(MiscPHashMap HMap, MiscPHashMapKey Key)

    MiscPHMResult MiscPHashMapSet(MiscPHashMap HMap,
                                  MiscPHashMapKey Key,
                                  MiscPHashMapValue Value)

    MiscSetErrorFuncType MiscSetFatalErrorFunc(MiscSetErrorFuncType ErrorFunc)

    RLStruct *RLNewFromFile(const char *FileName)

    IPAttributeStruct *_AttrMallocAttributeHashNum(IPAttrNumType AttribHashNum,
                                                   IPAttributeType Type)

    IPAttributeStruct *_AttrMallocAttributeIDType(IPAttrNumType AttribID,
                                                  IPAttributeType Type)

    IPAttributeStruct *_AttrMallocAttributeNameType(const char *Name,
                                                    IPAttributeType Type)

    IrtBType *_IrtImgVerifyAlignment(IrtBType *Data,
                                     int *MaxX,
                                     int *MaxY,
                                     int Alpha)

    FILE *_wfopen(const wchar_t *Filename, const wchar_t *Mode)

    wchar_t *_wgetenv(const wchar_t *WName)

    FILE *_wpopen(const wchar_t *Command, const wchar_t *Mode)

    char *getcwd(char *s, int Len)

    void movmem(VoidPtr Src, VoidPtr Dest, int Len)

    const char *searchpath(const char *Name, char *FullPath)

    const wchar_t *searchpathW(const wchar_t *Name, wchar_t *FullPath)

    int stricmp(const char *s1, const char *s2)

    int strnicmp(const char *s1, const char *s2, int n)

    char *strstr(const char *s, const char *Pattern)