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

    IPAttributeStruct *AttrCopyAttributes(const IPAttributeStruct *Src)

    const char **AttrCopyValidAttrList(const char **AttrNames)

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

    void AttrFreeAttributes(IPAttributeStruct **Attrs)

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

    const char *AttrGetAttribName(const IPAttributeStruct *Attr)

    int AttrGetColor(const IPAttributeStruct *Attrs)

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

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

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

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

    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)

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

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

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

    IrtRType AttrGetWidth(const IPAttributeStruct *Attrs)

    IPAttributeStruct *AttrReverseAttributes(IPAttributeStruct *Attr)

    void AttrSetColor(IPAttributeStruct **Attrs, int Color)

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

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

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

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

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

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

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

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

    void AttrSetWidth(IPAttributeStruct **Attrs, IrtRType Width)

    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)

    IrtRType IritCPUTime(int Reset)

    void IritCheckMarkDynMemory(IrtRType *Start)

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

    void IritConfigPrint(const IritConfigStruct *SetUp, int NumVar)

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

    void IritDebugMallocSearchPtr(VoidPtr p, int Abort)

    IritE2TExprNodeParamFuncType IritE2Expt2TreeSetFetchParamValueFunc(
                                IritE2TExprNodeParamFuncType FetchParamValueFunc)

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

    IritE2TExprNodeStruct *IritE2TCopyTree(const IritE2TExprNodeStruct *Root)

    int IritE2TDerivError(void)

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

    IrtRType IritE2TEvalTree(const IritE2TExprNodeStruct *Root)

    IritE2TExprNodeStruct *IritE2TExpr2Tree(const char s[])

    void IritE2TFreeTree(IritE2TExprNodeStruct *Root)

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

    int IritE2TParseError(void)

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

    void IritE2TSetParamValue(IrtRType Value, int Index)

    void IritFatalError(const char *Msg)

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

    void IritFree(VoidPtr 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 IritInformationMsg(const char *Msg)

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

    void IritInitTestDynMemory(void)

    void IritInitTestDynMemory2(int DebugMalloc,
                                IritIntPtrSizeType DebugSearchPtr,
                                int DebugSearchPtrAbort)

    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)

    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 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(void)

    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)

    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 *IritStrUpper(char *s)

    char *IritStrdup(const char *s)

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

    void IritTestAllDynMemory(void)

    void IritWarningMsg(const char *Msg)

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

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

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

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

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

    void IrtImgReadClrCache(void)

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

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

    int IrtImgReadImageXAlign(int Alignment)

    void IrtImgWriteCloseFile(void)

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

    void IrtImgWritePutLine(IrtBType *Alpha, IrtImgPixelStruct *Pixels)

    IrtImgImageType IrtImgWriteSetType(const char *ImageType)

    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)

    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 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)

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

    void MatTranslateFactorMatrix(IrtHmgnMatType M, IrtVecType Trans)

    void MatTranspMatrix(IrtHmgnMatType M, IrtHmgnMatType TranspM)

    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)

    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)

    MiscSetErrorFuncType MiscSetFatalErrorFunc(MiscSetErrorFuncType ErrorFunc)

    RLStruct *RLNewFromFile(const char *FileName)

    char *getcwd(char *s, int Len)

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

    const char *searchpath(const char *Name)

    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)