# This file was automatically generated by SWIG
package pslib;
require Exporter;
require DynaLoader;
@ISA = qw(Exporter DynaLoader);
package pslibc;
bootstrap pslib;
package pslib;
@EXPORT = qw( );

# ---------- BASE METHODS -------------

package pslib;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package pslib;

*psAbort = *pslibc::psAbort;
*psLibVersion = *pslibc::psLibVersion;
*psLibInit = *pslibc::psLibInit;
*psLibFinalize = *pslibc::psLibFinalize;
*psErrorDescriptionAlloc = *pslibc::psErrorDescriptionAlloc;
*psErrorCodeString = *pslibc::psErrorCodeString;
*psErrorRegister = *pslibc::psErrorRegister;
*p_psErrorUnregister = *pslibc::p_psErrorUnregister;
*psErrorGet = *pslibc::psErrorGet;
*psErrorLast = *pslibc::psErrorLast;
*psErrorClear = *pslibc::psErrorClear;
*psErrorGetStackSize = *pslibc::psErrorGetStackSize;
*psErrorStackPrint = *pslibc::psErrorStackPrint;
*p_psError = *pslibc::p_psError;
*p_psWarning = *pslibc::p_psWarning;
*psErrAlloc = *pslibc::psErrAlloc;
*psLogSetDestination = *pslibc::psLogSetDestination;
*psLogSetLevel = *pslibc::psLogSetLevel;
*psLogSetFormat = *pslibc::psLogSetFormat;
*psLogMsg = *pslibc::psLogMsg;
*p_psAlloc = *pslibc::p_psAlloc;
*p_psMemSetDeallocator = *pslibc::p_psMemSetDeallocator;
*p_psMemGetDeallocator = *pslibc::p_psMemGetDeallocator;
*p_psMemSetPersistent = *pslibc::p_psMemSetPersistent;
*p_psMemGetPersistent = *pslibc::p_psMemGetPersistent;
*p_psRealloc = *pslibc::p_psRealloc;
*p_psFree = *pslibc::p_psFree;
*psMemCheckLeaks = *pslibc::psMemCheckLeaks;
*psMemCheckCorruption = *pslibc::psMemCheckCorruption;
*psMemGetRefCounter = *pslibc::psMemGetRefCounter;
*p_psMemIncrRefCounter = *pslibc::p_psMemIncrRefCounter;
*p_psMemDecrRefCounter = *pslibc::p_psMemDecrRefCounter;
*psMemProblemCallbackSet = *pslibc::psMemProblemCallbackSet;
*psMemExhaustedCallbackSet = *pslibc::psMemExhaustedCallbackSet;
*psMemAllocateCallbackSet = *pslibc::psMemAllocateCallbackSet;
*psMemFreeCallbackSet = *pslibc::psMemFreeCallbackSet;
*psMemGetId = *pslibc::psMemGetId;
*psMemAllocateCallbackSetID = *pslibc::psMemAllocateCallbackSetID;
*psMemFreeCallbackSetID = *pslibc::psMemFreeCallbackSetID;
*psStringCopy = *pslibc::psStringCopy;
*psStringNCopy = *pslibc::psStringNCopy;
*p_psTrace = *pslibc::p_psTrace;
*psTraceSetLevel = *pslibc::psTraceSetLevel;
*psTraceGetLevel = *pslibc::psTraceGetLevel;
*psTraceReset = *pslibc::psTraceReset;
*psTracePrintLevels = *pslibc::psTracePrintLevels;
*psTraceSetDestination = *pslibc::psTraceSetDestination;
*psError = *pslibc::psError;
*psAlloc = *pslibc::psAlloc;
*psRealloc = *pslibc::psRealloc;
*psFree = *pslibc::psFree;
*psMemIncrRefCounter = *pslibc::psMemIncrRefCounter;
*psMemDecrRefCounter = *pslibc::psMemDecrRefCounter;
*psTrace = *pslibc::psTrace;
*psMemCheckLeaksToStderr = *pslibc::psMemCheckLeaksToStderr;
*psMemCheckLeaksToStdout = *pslibc::psMemCheckLeaksToStdout;
*psKernelAlloc = *pslibc::psKernelAlloc;
*psKernelGenerate = *pslibc::psKernelGenerate;
*psImageConvolve = *pslibc::psImageConvolve;
*psImageSubset = *pslibc::psImageSubset;
*psImageSubsection = *pslibc::psImageSubsection;
*psImageTrim = *pslibc::psImageTrim;
*psImageSlice = *pslibc::psImageSlice;
*psImageCut = *pslibc::psImageCut;
*psImageRadialCut = *pslibc::psImageRadialCut;
*psImageFFT = *pslibc::psImageFFT;
*psImageReal = *pslibc::psImageReal;
*psImageImaginary = *pslibc::psImageImaginary;
*psImageComplex = *pslibc::psImageComplex;
*psImageConjugate = *pslibc::psImageConjugate;
*psImagePowerSpectrum = *pslibc::psImagePowerSpectrum;
*psImageAlloc = *pslibc::psImageAlloc;
*psRegionAlloc = *pslibc::psRegionAlloc;
*psRegionFromString = *pslibc::psRegionFromString;
*psRegionToString = *pslibc::psRegionToString;
*psImageRecycle = *pslibc::psImageRecycle;
*psImageCopy = *pslibc::psImageCopy;
*psImageFreeChildren = *pslibc::psImageFreeChildren;
*psImagePixelInterpolate = *pslibc::psImagePixelInterpolate;
*psImageReadSection = *pslibc::psImageReadSection;
*psImageWriteSection = *pslibc::psImageWriteSection;
*psImageClip = *pslibc::psImageClip;
*psImageClipComplexRegion = *pslibc::psImageClipComplexRegion;
*psImageClipNaN = *pslibc::psImageClipNaN;
*psImageOverlaySection = *pslibc::psImageOverlaySection;
*psImageRebin = *pslibc::psImageRebin;
*psImageResample = *pslibc::psImageResample;
*psImageRotate = *pslibc::psImageRotate;
*psImageShift = *pslibc::psImageShift;
*psImageRoll = *pslibc::psImageRoll;
*psImageTransform = *pslibc::psImageTransform;
*psImageStats = *pslibc::psImageStats;
*psImageHistogram = *pslibc::psImageHistogram;
*psImageFitPolynomial = *pslibc::psImageFitPolynomial;
*psImageEvalPolynomial = *pslibc::psImageEvalPolynomial;
*psFitsAlloc = *pslibc::psFitsAlloc;
*psFitsMoveExtName = *pslibc::psFitsMoveExtName;
*psFitsMoveExtNum = *pslibc::psFitsMoveExtNum;
*psFitsGetExtNum = *pslibc::psFitsGetExtNum;
*psFitsGetExtName = *pslibc::psFitsGetExtName;
*psFitsSetExtName = *pslibc::psFitsSetExtName;
*psFitsGetSize = *pslibc::psFitsGetSize;
*psFitsGetExtType = *pslibc::psFitsGetExtType;
*psFitsReadHeader = *pslibc::psFitsReadHeader;
*psFitsReadHeaderSet = *pslibc::psFitsReadHeaderSet;
*psFitsWriteHeader = *pslibc::psFitsWriteHeader;
*psFitsReadImage = *pslibc::psFitsReadImage;
*psFitsWriteImage = *pslibc::psFitsWriteImage;
*psFitsUpdateImage = *pslibc::psFitsUpdateImage;
*psFitsReadTableRow = *pslibc::psFitsReadTableRow;
*psFitsReadTableColumn = *pslibc::psFitsReadTableColumn;
*psFitsReadTableColumnNum = *pslibc::psFitsReadTableColumnNum;
*psFitsReadTable = *pslibc::psFitsReadTable;
*psFitsWriteTable = *pslibc::psFitsWriteTable;
*psFitsUpdateTable = *pslibc::psFitsUpdateTable;
*psLookupTableAlloc = *pslibc::psLookupTableAlloc;
*psLookupTableRead = *pslibc::psLookupTableRead;
*psLookupTableInterpolate = *pslibc::psLookupTableInterpolate;
*psLookupTableInterpolateAll = *pslibc::psLookupTableInterpolateAll;
*psGaussian = *pslibc::psGaussian;
*p_psGaussianDev = *pslibc::p_psGaussianDev;
*psPolynomial1DAlloc = *pslibc::psPolynomial1DAlloc;
*psPolynomial2DAlloc = *pslibc::psPolynomial2DAlloc;
*psPolynomial3DAlloc = *pslibc::psPolynomial3DAlloc;
*psPolynomial4DAlloc = *pslibc::psPolynomial4DAlloc;
*psPolynomial1DEval = *pslibc::psPolynomial1DEval;
*psPolynomial2DEval = *pslibc::psPolynomial2DEval;
*psPolynomial3DEval = *pslibc::psPolynomial3DEval;
*psPolynomial4DEval = *pslibc::psPolynomial4DEval;
*psPolynomial1DEvalVector = *pslibc::psPolynomial1DEvalVector;
*psPolynomial2DEvalVector = *pslibc::psPolynomial2DEvalVector;
*psPolynomial3DEvalVector = *pslibc::psPolynomial3DEvalVector;
*psPolynomial4DEvalVector = *pslibc::psPolynomial4DEvalVector;
*psDPolynomial1DAlloc = *pslibc::psDPolynomial1DAlloc;
*psDPolynomial2DAlloc = *pslibc::psDPolynomial2DAlloc;
*psDPolynomial3DAlloc = *pslibc::psDPolynomial3DAlloc;
*psDPolynomial4DAlloc = *pslibc::psDPolynomial4DAlloc;
*psDPolynomial1DEval = *pslibc::psDPolynomial1DEval;
*psDPolynomial2DEval = *pslibc::psDPolynomial2DEval;
*psDPolynomial3DEval = *pslibc::psDPolynomial3DEval;
*psDPolynomial4DEval = *pslibc::psDPolynomial4DEval;
*psDPolynomial1DEvalVector = *pslibc::psDPolynomial1DEvalVector;
*psDPolynomial2DEvalVector = *pslibc::psDPolynomial2DEvalVector;
*psDPolynomial3DEvalVector = *pslibc::psDPolynomial3DEvalVector;
*psDPolynomial4DEvalVector = *pslibc::psDPolynomial4DEvalVector;
*psSpline1DAlloc = *pslibc::psSpline1DAlloc;
*psSpline1DAllocGeneric = *pslibc::psSpline1DAllocGeneric;
*psSpline1DEval = *pslibc::psSpline1DEval;
*psSpline1DEvalVector = *pslibc::psSpline1DEvalVector;
*p_psVectorBinDisect = *pslibc::p_psVectorBinDisect;
*p_psVectorInterpolate = *pslibc::p_psVectorInterpolate;
*psMatrixLUD = *pslibc::psMatrixLUD;
*psMatrixLUSolve = *pslibc::psMatrixLUSolve;
*psMatrixInvert = *pslibc::psMatrixInvert;
*psMatrixDeterminant = *pslibc::psMatrixDeterminant;
*psMatrixMultiply = *pslibc::psMatrixMultiply;
*psMatrixTranspose = *pslibc::psMatrixTranspose;
*psMatrixEigenvectors = *pslibc::psMatrixEigenvectors;
*psMatrixToVector = *pslibc::psMatrixToVector;
*psVectorToMatrix = *pslibc::psVectorToMatrix;
*psBinaryOp = *pslibc::psBinaryOp;
*psUnaryOp = *pslibc::psUnaryOp;
*psMinimizationAlloc = *pslibc::psMinimizationAlloc;
*psVectorFitPolynomial1D = *pslibc::psVectorFitPolynomial1D;
*psVectorFitSpline1D = *pslibc::psVectorFitSpline1D;
*psMinimizeLMChi2 = *pslibc::psMinimizeLMChi2;
*psMinimizePowell = *pslibc::psMinimizePowell;
*psMinimizeLMChi2Gauss1D = *pslibc::psMinimizeLMChi2Gauss1D;
*psMinimizePowellChi2Gauss1D = *pslibc::psMinimizePowellChi2Gauss1D;
*psMinimizeChi2Powell = *pslibc::psMinimizeChi2Powell;
*psRandomAlloc = *pslibc::psRandomAlloc;
*psRandomReset = *pslibc::psRandomReset;
*psRandomUniform = *pslibc::psRandomUniform;
*psRandomGaussian = *pslibc::psRandomGaussian;
*psRandomPoisson = *pslibc::psRandomPoisson;
*psVectorStats = *pslibc::psVectorStats;
*psStatsAlloc = *pslibc::psStatsAlloc;
*psHistogramAlloc = *pslibc::psHistogramAlloc;
*psHistogramAllocGeneric = *pslibc::psHistogramAllocGeneric;
*psVectorHistogram = *pslibc::psVectorHistogram;
*p_psGetStatValue = *pslibc::p_psGetStatValue;
*p_psNormalizeVectorRangeU8 = *pslibc::p_psNormalizeVectorRangeU8;
*p_psNormalizeVectorRangeU16 = *pslibc::p_psNormalizeVectorRangeU16;
*p_psNormalizeVectorRangeU32 = *pslibc::p_psNormalizeVectorRangeU32;
*p_psNormalizeVectorRangeU64 = *pslibc::p_psNormalizeVectorRangeU64;
*p_psNormalizeVectorRangeS8 = *pslibc::p_psNormalizeVectorRangeS8;
*p_psNormalizeVectorRangeS16 = *pslibc::p_psNormalizeVectorRangeS16;
*p_psNormalizeVectorRangeS32 = *pslibc::p_psNormalizeVectorRangeS32;
*p_psNormalizeVectorRangeS64 = *pslibc::p_psNormalizeVectorRangeS64;
*p_psNormalizeVectorRangeF32 = *pslibc::p_psNormalizeVectorRangeF32;
*p_psNormalizeVectorRangeF64 = *pslibc::p_psNormalizeVectorRangeF64;
*psVectorFFT = *pslibc::psVectorFFT;
*psVectorReal = *pslibc::psVectorReal;
*psVectorImaginary = *pslibc::psVectorImaginary;
*psVectorComplex = *pslibc::psVectorComplex;
*psVectorConjugate = *pslibc::psVectorConjugate;
*psVectorPowerSpectrum = *pslibc::psVectorPowerSpectrum;
*psArrayAlloc = *pslibc::psArrayAlloc;
*psArrayRealloc = *pslibc::psArrayRealloc;
*psArrayAdd = *pslibc::psArrayAdd;
*psArrayRemove = *pslibc::psArrayRemove;
*psArrayElementFree = *pslibc::psArrayElementFree;
*psArraySort = *pslibc::psArraySort;
*psArraySet = *pslibc::psArraySet;
*psArrayGet = *pslibc::psArrayGet;
*psBitSetAlloc = *pslibc::psBitSetAlloc;
*psBitSetSet = *pslibc::psBitSetSet;
*psBitSetClear = *pslibc::psBitSetClear;
*psBitSetTest = *pslibc::psBitSetTest;
*psBitSetOp = *pslibc::psBitSetOp;
*psBitSetNot = *pslibc::psBitSetNot;
*psBitSetToString = *pslibc::psBitSetToString;
*psCompareS8Ptr = *pslibc::psCompareS8Ptr;
*psCompareS16Ptr = *pslibc::psCompareS16Ptr;
*psCompareS32Ptr = *pslibc::psCompareS32Ptr;
*psCompareS64Ptr = *pslibc::psCompareS64Ptr;
*psCompareU8Ptr = *pslibc::psCompareU8Ptr;
*psCompareU16Ptr = *pslibc::psCompareU16Ptr;
*psCompareU32Ptr = *pslibc::psCompareU32Ptr;
*psCompareU64Ptr = *pslibc::psCompareU64Ptr;
*psCompareF32Ptr = *pslibc::psCompareF32Ptr;
*psCompareF64Ptr = *pslibc::psCompareF64Ptr;
*psCompareDescendingS8Ptr = *pslibc::psCompareDescendingS8Ptr;
*psCompareDescendingS16Ptr = *pslibc::psCompareDescendingS16Ptr;
*psCompareDescendingS32Ptr = *pslibc::psCompareDescendingS32Ptr;
*psCompareDescendingS64Ptr = *pslibc::psCompareDescendingS64Ptr;
*psCompareDescendingU8Ptr = *pslibc::psCompareDescendingU8Ptr;
*psCompareDescendingU16Ptr = *pslibc::psCompareDescendingU16Ptr;
*psCompareDescendingU32Ptr = *pslibc::psCompareDescendingU32Ptr;
*psCompareDescendingU64Ptr = *pslibc::psCompareDescendingU64Ptr;
*psCompareDescendingF32Ptr = *pslibc::psCompareDescendingF32Ptr;
*psCompareDescendingF64Ptr = *pslibc::psCompareDescendingF64Ptr;
*psCompareS8 = *pslibc::psCompareS8;
*psCompareS16 = *pslibc::psCompareS16;
*psCompareS32 = *pslibc::psCompareS32;
*psCompareS64 = *pslibc::psCompareS64;
*psCompareU8 = *pslibc::psCompareU8;
*psCompareU16 = *pslibc::psCompareU16;
*psCompareU32 = *pslibc::psCompareU32;
*psCompareU64 = *pslibc::psCompareU64;
*psCompareF32 = *pslibc::psCompareF32;
*psCompareF64 = *pslibc::psCompareF64;
*psCompareDescendingS8 = *pslibc::psCompareDescendingS8;
*psCompareDescendingS16 = *pslibc::psCompareDescendingS16;
*psCompareDescendingS32 = *pslibc::psCompareDescendingS32;
*psCompareDescendingS64 = *pslibc::psCompareDescendingS64;
*psCompareDescendingU8 = *pslibc::psCompareDescendingU8;
*psCompareDescendingU16 = *pslibc::psCompareDescendingU16;
*psCompareDescendingU32 = *pslibc::psCompareDescendingU32;
*psCompareDescendingU64 = *pslibc::psCompareDescendingU64;
*psCompareDescendingF32 = *pslibc::psCompareDescendingF32;
*psCompareDescendingF64 = *pslibc::psCompareDescendingF64;
*psHashAlloc = *pslibc::psHashAlloc;
*psHashAdd = *pslibc::psHashAdd;
*psHashLookup = *pslibc::psHashLookup;
*psHashRemove = *pslibc::psHashRemove;
*psHashKeyList = *pslibc::psHashKeyList;
*psHashToArray = *pslibc::psHashToArray;
*psListAlloc = *pslibc::psListAlloc;
*psListIteratorAlloc = *pslibc::psListIteratorAlloc;
*psListIteratorSet = *pslibc::psListIteratorSet;
*psListAdd = *pslibc::psListAdd;
*psListAddAfter = *pslibc::psListAddAfter;
*psListAddBefore = *pslibc::psListAddBefore;
*psListRemove = *pslibc::psListRemove;
*psListRemoveData = *pslibc::psListRemoveData;
*psListGet = *pslibc::psListGet;
*psListGetAndIncrement = *pslibc::psListGetAndIncrement;
*psListGetAndDecrement = *pslibc::psListGetAndDecrement;
*psListToArray = *pslibc::psListToArray;
*psArrayToList = *pslibc::psArrayToList;
*psListSort = *pslibc::psListSort;
*psScalarAlloc = *pslibc::psScalarAlloc;
*psScalarCopy = *pslibc::psScalarCopy;
*psVectorAlloc = *pslibc::psVectorAlloc;
*psVectorRealloc = *pslibc::psVectorRealloc;
*psVectorRecycle = *pslibc::psVectorRecycle;
*psVectorCopy = *pslibc::psVectorCopy;
*psVectorSort = *pslibc::psVectorSort;
*psVectorSortIndex = *pslibc::psVectorSortIndex;
*psVectorToString = *pslibc::psVectorToString;
*p_psVectorGetElementF64 = *pslibc::p_psVectorGetElementF64;
*psFixedPatternAlloc = *pslibc::psFixedPatternAlloc;
*psExposureAlloc = *pslibc::psExposureAlloc;
*psObservatoryAlloc = *pslibc::psObservatoryAlloc;
*psFPAAlloc = *pslibc::psFPAAlloc;
*psChipAlloc = *pslibc::psChipAlloc;
*psCellAlloc = *pslibc::psCellAlloc;
*psReadoutAlloc = *pslibc::psReadoutAlloc;
*psGrommitAlloc = *pslibc::psGrommitAlloc;
*psCellInFPA = *pslibc::psCellInFPA;
*psChipInFPA = *pslibc::psChipInFPA;
*psCellInChip = *pslibc::psCellInChip;
*psCoordCellToChip = *pslibc::psCoordCellToChip;
*psCoordChipToFPA = *pslibc::psCoordChipToFPA;
*psCoordFPAToTP = *pslibc::psCoordFPAToTP;
*psCoordTPToSky = *pslibc::psCoordTPToSky;
*psCoordCellToFPA = *pslibc::psCoordCellToFPA;
*psCoordCellToSky = *pslibc::psCoordCellToSky;
*psCoordCellToSkyQuick = *pslibc::psCoordCellToSkyQuick;
*psCoordSkyToTP = *pslibc::psCoordSkyToTP;
*psCoordTPToFPA = *pslibc::psCoordTPToFPA;
*psCoordFPAToChip = *pslibc::psCoordFPAToChip;
*psCoordChipToCell = *pslibc::psCoordChipToCell;
*psCoordSkyToCell = *pslibc::psCoordSkyToCell;
*psCoordSkyToCellQuick = *pslibc::psCoordSkyToCellQuick;
*psPlaneAlloc = *pslibc::psPlaneAlloc;
*psSphereAlloc = *pslibc::psSphereAlloc;
*psPlaneTransformAlloc = *pslibc::psPlaneTransformAlloc;
*psPlaneTransformApply = *pslibc::psPlaneTransformApply;
*psPlaneDistortAlloc = *pslibc::psPlaneDistortAlloc;
*psPlaneDistortApply = *pslibc::psPlaneDistortApply;
*psSphereTransformAlloc = *pslibc::psSphereTransformAlloc;
*psSphereTransformApply = *pslibc::psSphereTransformApply;
*psSphereTransformICRSToEcliptic = *pslibc::psSphereTransformICRSToEcliptic;
*psSphereTransformEclipticToICRS = *pslibc::psSphereTransformEclipticToICRS;
*psSphereTransformICRSToGalactic = *pslibc::psSphereTransformICRSToGalactic;
*psSphereTransformGalacticToICRS = *pslibc::psSphereTransformGalacticToICRS;
*psProjectionAlloc = *pslibc::psProjectionAlloc;
*psProject = *pslibc::psProject;
*psDeproject = *pslibc::psDeproject;
*psSphereGetOffset = *pslibc::psSphereGetOffset;
*psSphereSetOffset = *pslibc::psSphereSetOffset;
*psSpherePrecess = *pslibc::psSpherePrecess;
*p_psPlaneTransformLinearInvert = *pslibc::p_psPlaneTransformLinearInvert;
*p_psIsProjectionLinear = *pslibc::p_psIsProjectionLinear;
*psPlaneTransformInvert = *pslibc::psPlaneTransformInvert;
*psPlaneTransformCombine = *pslibc::psPlaneTransformCombine;
*psPlaneTransformFit = *pslibc::psPlaneTransformFit;
*psMetadataItemAlloc = *pslibc::psMetadataItemAlloc;
*psMetadataItemAllocStr = *pslibc::psMetadataItemAllocStr;
*psMetadataItemAllocF32 = *pslibc::psMetadataItemAllocF32;
*psMetadataItemAllocF64 = *pslibc::psMetadataItemAllocF64;
*psMetadataItemAllocS32 = *pslibc::psMetadataItemAllocS32;
*psMetadataItemAllocBool = *pslibc::psMetadataItemAllocBool;
*psMetadataAlloc = *pslibc::psMetadataAlloc;
*psMetadataAddItem = *pslibc::psMetadataAddItem;
*psMetadataAdd = *pslibc::psMetadataAdd;
*psMetadataAddS32 = *pslibc::psMetadataAddS32;
*psMetadataAddF32 = *pslibc::psMetadataAddF32;
*psMetadataAddF64 = *pslibc::psMetadataAddF64;
*psMetadataAddList = *pslibc::psMetadataAddList;
*psMetadataAddStr = *pslibc::psMetadataAddStr;
*psMetadataAddVector = *pslibc::psMetadataAddVector;
*psMetadataAddImage = *pslibc::psMetadataAddImage;
*psMetadataAddHash = *pslibc::psMetadataAddHash;
*psMetadataAddLookupTable = *pslibc::psMetadataAddLookupTable;
*psMetadataAddUnknown = *pslibc::psMetadataAddUnknown;
*psMetadataRemove = *pslibc::psMetadataRemove;
*psMetadataLookup = *pslibc::psMetadataLookup;
*psMetadataLookupF64 = *pslibc::psMetadataLookupF64;
*psMetadataLookupF32 = *pslibc::psMetadataLookupF32;
*psMetadataLookupS32 = *pslibc::psMetadataLookupS32;
*psMetadataLookupBool = *pslibc::psMetadataLookupBool;
*psMetadataLookupPtr = *pslibc::psMetadataLookupPtr;
*psMetadataGet = *pslibc::psMetadataGet;
*psMetadataIteratorAlloc = *pslibc::psMetadataIteratorAlloc;
*psMetadataIteratorSet = *pslibc::psMetadataIteratorSet;
*psMetadataGetAndIncrement = *pslibc::psMetadataGetAndIncrement;
*psMetadataGetAndDecrement = *pslibc::psMetadataGetAndDecrement;
*psMetadataItemPrint = *pslibc::psMetadataItemPrint;
*psMetadataReadHeader = *pslibc::psMetadataReadHeader;
*psMetadataParseConfig = *pslibc::psMetadataParseConfig;
*psMetadataParseConfigXml = *pslibc::psMetadataParseConfigXml;
*p_psTimeInit = *pslibc::p_psTimeInit;
*p_psTimeFinalize = *pslibc::p_psTimeFinalize;
*psTimeAlloc = *pslibc::psTimeAlloc;
*psTimeGetTime = *pslibc::psTimeGetTime;
*psTimeConvert = *pslibc::psTimeConvert;
*psTimeToLST = *pslibc::psTimeToLST;
*psTimeGetUT1Delta = *pslibc::psTimeGetUT1Delta;
*psTimeGetTAIDelta = *pslibc::psTimeGetTAIDelta;
*psTimeGetPoleCoords = *pslibc::psTimeGetPoleCoords;
*psTimeLeapseconds = *pslibc::psTimeLeapseconds;
*psTimeToJD = *pslibc::psTimeToJD;
*psTimeToMJD = *pslibc::psTimeToMJD;
*psTimeToISOTime = *pslibc::psTimeToISOTime;
*psTimeToTimeval = *pslibc::psTimeToTimeval;
*psTimeToTM = *pslibc::psTimeToTM;
*psTimeFromJD = *pslibc::psTimeFromJD;
*psTimeFromMJD = *pslibc::psTimeFromMJD;
*psTimeFromISOTime = *pslibc::psTimeFromISOTime;
*psTimeFromTimeval = *pslibc::psTimeFromTimeval;
*psTimeFromTM = *pslibc::psTimeFromTM;
*psTimeMath = *pslibc::psTimeMath;
*psTimeDelta = *pslibc::psTimeDelta;
*p_psGetConfigFileName = *pslibc::p_psGetConfigFileName;

############# Class : pslib::psC32 ##############

package pslib::psC32;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_re_get = *pslibc::psC32_re_get;
*swig_re_set = *pslibc::psC32_re_set;
*swig_im_get = *pslibc::psC32_im_get;
*swig_im_set = *pslibc::psC32_im_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psC32(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psC32($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psC64 ##############

package pslib::psC64;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_re_get = *pslibc::psC64_re_get;
*swig_re_set = *pslibc::psC64_re_set;
*swig_im_get = *pslibc::psC64_im_get;
*swig_im_set = *pslibc::psC64_im_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psC64(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psC64($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psType ##############

package pslib::psType;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psType_type_get;
*swig_type_set = *pslibc::psType_type_set;
*swig_dimen_get = *pslibc::psType_dimen_get;
*swig_dimen_set = *pslibc::psType_dimen_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psType(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psType($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMath ##############

package pslib::psMath;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psMath_type_get;
*swig_type_set = *pslibc::psMath_type_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMath(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMath($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psErrorDescription ##############

package pslib::psErrorDescription;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_code_get = *pslibc::psErrorDescription_code_get;
*swig_code_set = *pslibc::psErrorDescription_code_set;
*swig_description_get = *pslibc::psErrorDescription_description_get;
*swig_description_set = *pslibc::psErrorDescription_description_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psErrorDescription(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psErrorDescription($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psErr ##############

package pslib::psErr;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_name_get = *pslibc::psErr_name_get;
*swig_name_set = *pslibc::psErr_name_set;
*swig_code_get = *pslibc::psErr_code_get;
*swig_code_set = *pslibc::psErr_code_set;
*swig_msg_get = *pslibc::psErr_msg_get;
*swig_msg_set = *pslibc::psErr_msg_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psErr(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psErr($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMemBlock ##############

package pslib::psMemBlock;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_startblock_get = *pslibc::psMemBlock_startblock_get;
*swig_startblock_set = *pslibc::psMemBlock_startblock_set;
*swig_previousBlock_get = *pslibc::psMemBlock_previousBlock_get;
*swig_previousBlock_set = *pslibc::psMemBlock_previousBlock_set;
*swig_nextBlock_get = *pslibc::psMemBlock_nextBlock_get;
*swig_nextBlock_set = *pslibc::psMemBlock_nextBlock_set;
*swig_freeFcn_get = *pslibc::psMemBlock_freeFcn_get;
*swig_freeFcn_set = *pslibc::psMemBlock_freeFcn_set;
*swig_userMemorySize_get = *pslibc::psMemBlock_userMemorySize_get;
*swig_userMemorySize_set = *pslibc::psMemBlock_userMemorySize_set;
*swig_id_get = *pslibc::psMemBlock_id_get;
*swig_id_set = *pslibc::psMemBlock_id_set;
*swig_file_get = *pslibc::psMemBlock_file_get;
*swig_file_set = *pslibc::psMemBlock_file_set;
*swig_lineno_get = *pslibc::psMemBlock_lineno_get;
*swig_lineno_set = *pslibc::psMemBlock_lineno_set;
*swig_refCounterMutex_get = *pslibc::psMemBlock_refCounterMutex_get;
*swig_refCounterMutex_set = *pslibc::psMemBlock_refCounterMutex_set;
*swig_refCounter_get = *pslibc::psMemBlock_refCounter_get;
*swig_refCounter_set = *pslibc::psMemBlock_refCounter_set;
*swig_persistent_get = *pslibc::psMemBlock_persistent_get;
*swig_persistent_set = *pslibc::psMemBlock_persistent_set;
*swig_endblock_get = *pslibc::psMemBlock_endblock_get;
*swig_endblock_set = *pslibc::psMemBlock_endblock_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMemBlock(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMemBlock($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::p_psComponent ##############

package pslib::p_psComponent;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_name_get = *pslibc::p_psComponent_name_get;
*swig_name_set = *pslibc::p_psComponent_name_set;
*swig_level_get = *pslibc::p_psComponent_level_get;
*swig_level_set = *pslibc::p_psComponent_level_set;
*swig_p_psSpecified_get = *pslibc::p_psComponent_p_psSpecified_get;
*swig_p_psSpecified_set = *pslibc::p_psComponent_p_psSpecified_set;
*swig_n_get = *pslibc::p_psComponent_n_get;
*swig_n_set = *pslibc::p_psComponent_n_set;
*swig_subcomp_get = *pslibc::p_psComponent_subcomp_get;
*swig_subcomp_set = *pslibc::p_psComponent_subcomp_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_p_psComponent(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_p_psComponent($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psKernel ##############

package pslib::psKernel;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_image_get = *pslibc::psKernel_image_get;
*swig_image_set = *pslibc::psKernel_image_set;
*swig_xMin_get = *pslibc::psKernel_xMin_get;
*swig_xMin_set = *pslibc::psKernel_xMin_set;
*swig_yMin_get = *pslibc::psKernel_yMin_get;
*swig_yMin_set = *pslibc::psKernel_yMin_set;
*swig_xMax_get = *pslibc::psKernel_xMax_get;
*swig_xMax_set = *pslibc::psKernel_xMax_set;
*swig_yMax_get = *pslibc::psKernel_yMax_get;
*swig_yMax_set = *pslibc::psKernel_yMax_set;
*swig_kernel_get = *pslibc::psKernel_kernel_get;
*swig_kernel_set = *pslibc::psKernel_kernel_set;
*swig_p_kernelRows_get = *pslibc::psKernel_p_kernelRows_get;
*swig_p_kernelRows_set = *pslibc::psKernel_p_kernelRows_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psKernel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psKernel($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psImage ##############

package pslib::psImage;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psImage_type_get;
*swig_type_set = *pslibc::psImage_type_set;
*swig_numCols_get = *pslibc::psImage_numCols_get;
*swig_numCols_set = *pslibc::psImage_numCols_set;
*swig_numRows_get = *pslibc::psImage_numRows_get;
*swig_numRows_set = *pslibc::psImage_numRows_set;
*swig_col0_get = *pslibc::psImage_col0_get;
*swig_col0_set = *pslibc::psImage_col0_set;
*swig_row0_get = *pslibc::psImage_row0_get;
*swig_row0_set = *pslibc::psImage_row0_set;
*swig_parent_get = *pslibc::psImage_parent_get;
*swig_parent_set = *pslibc::psImage_parent_set;
*swig_children_get = *pslibc::psImage_children_get;
*swig_children_set = *pslibc::psImage_children_set;
*swig_rawDataBuffer_get = *pslibc::psImage_rawDataBuffer_get;
*swig_rawDataBuffer_set = *pslibc::psImage_rawDataBuffer_set;
*swig_data_get = *pslibc::psImage_data_get;
*swig_data_set = *pslibc::psImage_data_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psImage(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psImage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psImage_data ##############

package pslib::psImage_data;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_U8_get = *pslibc::psImage_data_U8_get;
*swig_U8_set = *pslibc::psImage_data_U8_set;
*swig_U16_get = *pslibc::psImage_data_U16_get;
*swig_U16_set = *pslibc::psImage_data_U16_set;
*swig_U32_get = *pslibc::psImage_data_U32_get;
*swig_U32_set = *pslibc::psImage_data_U32_set;
*swig_U64_get = *pslibc::psImage_data_U64_get;
*swig_U64_set = *pslibc::psImage_data_U64_set;
*swig_S8_get = *pslibc::psImage_data_S8_get;
*swig_S8_set = *pslibc::psImage_data_S8_set;
*swig_S16_get = *pslibc::psImage_data_S16_get;
*swig_S16_set = *pslibc::psImage_data_S16_set;
*swig_S32_get = *pslibc::psImage_data_S32_get;
*swig_S32_set = *pslibc::psImage_data_S32_set;
*swig_S64_get = *pslibc::psImage_data_S64_get;
*swig_S64_set = *pslibc::psImage_data_S64_set;
*swig_F32_get = *pslibc::psImage_data_F32_get;
*swig_F32_set = *pslibc::psImage_data_F32_set;
*swig_F64_get = *pslibc::psImage_data_F64_get;
*swig_F64_set = *pslibc::psImage_data_F64_set;
*swig_C32_get = *pslibc::psImage_data_C32_get;
*swig_C32_set = *pslibc::psImage_data_C32_set;
*swig_C64_get = *pslibc::psImage_data_C64_get;
*swig_C64_set = *pslibc::psImage_data_C64_set;
*swig_PTR_get = *pslibc::psImage_data_PTR_get;
*swig_PTR_set = *pslibc::psImage_data_PTR_set;
*swig_V_get = *pslibc::psImage_data_V_get;
*swig_V_set = *pslibc::psImage_data_V_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psImage_data(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psImage_data($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psRegion ##############

package pslib::psRegion;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_x0_get = *pslibc::psRegion_x0_get;
*swig_x0_set = *pslibc::psRegion_x0_set;
*swig_x1_get = *pslibc::psRegion_x1_get;
*swig_x1_set = *pslibc::psRegion_x1_set;
*swig_y0_get = *pslibc::psRegion_y0_get;
*swig_y0_set = *pslibc::psRegion_y0_set;
*swig_y1_get = *pslibc::psRegion_y1_get;
*swig_y1_set = *pslibc::psRegion_y1_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psRegion(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psRegion($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psFits ##############

package pslib::psFits;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_p_fd_get = *pslibc::psFits_p_fd_get;
*swig_p_fd_set = *pslibc::psFits_p_fd_set;
*swig_filename_get = *pslibc::psFits_filename_get;
*swig_filename_set = *pslibc::psFits_filename_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psFits(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psFits($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psLookupTable ##############

package pslib::psLookupTable;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_fileName_get = *pslibc::psLookupTable_fileName_get;
*swig_fileName_set = *pslibc::psLookupTable_fileName_set;
*swig_numRows_get = *pslibc::psLookupTable_numRows_get;
*swig_numRows_set = *pslibc::psLookupTable_numRows_set;
*swig_numCols_get = *pslibc::psLookupTable_numCols_get;
*swig_numCols_set = *pslibc::psLookupTable_numCols_set;
*swig_validFrom_get = *pslibc::psLookupTable_validFrom_get;
*swig_validFrom_set = *pslibc::psLookupTable_validFrom_set;
*swig_validTo_get = *pslibc::psLookupTable_validTo_get;
*swig_validTo_set = *pslibc::psLookupTable_validTo_set;
*swig_index_get = *pslibc::psLookupTable_index_get;
*swig_index_set = *pslibc::psLookupTable_index_set;
*swig_values_get = *pslibc::psLookupTable_values_get;
*swig_values_set = *pslibc::psLookupTable_values_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psLookupTable(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psLookupTable($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPolynomial1D ##############

package pslib::psPolynomial1D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psPolynomial1D_type_get;
*swig_type_set = *pslibc::psPolynomial1D_type_set;
*swig_n_get = *pslibc::psPolynomial1D_n_get;
*swig_n_set = *pslibc::psPolynomial1D_n_set;
*swig_coeff_get = *pslibc::psPolynomial1D_coeff_get;
*swig_coeff_set = *pslibc::psPolynomial1D_coeff_set;
*swig_coeffErr_get = *pslibc::psPolynomial1D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psPolynomial1D_coeffErr_set;
*swig_mask_get = *pslibc::psPolynomial1D_mask_get;
*swig_mask_set = *pslibc::psPolynomial1D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPolynomial1D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPolynomial1D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPolynomial2D ##############

package pslib::psPolynomial2D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psPolynomial2D_type_get;
*swig_type_set = *pslibc::psPolynomial2D_type_set;
*swig_nX_get = *pslibc::psPolynomial2D_nX_get;
*swig_nX_set = *pslibc::psPolynomial2D_nX_set;
*swig_nY_get = *pslibc::psPolynomial2D_nY_get;
*swig_nY_set = *pslibc::psPolynomial2D_nY_set;
*swig_coeff_get = *pslibc::psPolynomial2D_coeff_get;
*swig_coeff_set = *pslibc::psPolynomial2D_coeff_set;
*swig_coeffErr_get = *pslibc::psPolynomial2D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psPolynomial2D_coeffErr_set;
*swig_mask_get = *pslibc::psPolynomial2D_mask_get;
*swig_mask_set = *pslibc::psPolynomial2D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPolynomial2D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPolynomial2D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPolynomial3D ##############

package pslib::psPolynomial3D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psPolynomial3D_type_get;
*swig_type_set = *pslibc::psPolynomial3D_type_set;
*swig_nX_get = *pslibc::psPolynomial3D_nX_get;
*swig_nX_set = *pslibc::psPolynomial3D_nX_set;
*swig_nY_get = *pslibc::psPolynomial3D_nY_get;
*swig_nY_set = *pslibc::psPolynomial3D_nY_set;
*swig_nZ_get = *pslibc::psPolynomial3D_nZ_get;
*swig_nZ_set = *pslibc::psPolynomial3D_nZ_set;
*swig_coeff_get = *pslibc::psPolynomial3D_coeff_get;
*swig_coeff_set = *pslibc::psPolynomial3D_coeff_set;
*swig_coeffErr_get = *pslibc::psPolynomial3D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psPolynomial3D_coeffErr_set;
*swig_mask_get = *pslibc::psPolynomial3D_mask_get;
*swig_mask_set = *pslibc::psPolynomial3D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPolynomial3D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPolynomial3D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPolynomial4D ##############

package pslib::psPolynomial4D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psPolynomial4D_type_get;
*swig_type_set = *pslibc::psPolynomial4D_type_set;
*swig_nW_get = *pslibc::psPolynomial4D_nW_get;
*swig_nW_set = *pslibc::psPolynomial4D_nW_set;
*swig_nX_get = *pslibc::psPolynomial4D_nX_get;
*swig_nX_set = *pslibc::psPolynomial4D_nX_set;
*swig_nY_get = *pslibc::psPolynomial4D_nY_get;
*swig_nY_set = *pslibc::psPolynomial4D_nY_set;
*swig_nZ_get = *pslibc::psPolynomial4D_nZ_get;
*swig_nZ_set = *pslibc::psPolynomial4D_nZ_set;
*swig_coeff_get = *pslibc::psPolynomial4D_coeff_get;
*swig_coeff_set = *pslibc::psPolynomial4D_coeff_set;
*swig_coeffErr_get = *pslibc::psPolynomial4D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psPolynomial4D_coeffErr_set;
*swig_mask_get = *pslibc::psPolynomial4D_mask_get;
*swig_mask_set = *pslibc::psPolynomial4D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPolynomial4D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPolynomial4D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psDPolynomial1D ##############

package pslib::psDPolynomial1D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psDPolynomial1D_type_get;
*swig_type_set = *pslibc::psDPolynomial1D_type_set;
*swig_n_get = *pslibc::psDPolynomial1D_n_get;
*swig_n_set = *pslibc::psDPolynomial1D_n_set;
*swig_coeff_get = *pslibc::psDPolynomial1D_coeff_get;
*swig_coeff_set = *pslibc::psDPolynomial1D_coeff_set;
*swig_coeffErr_get = *pslibc::psDPolynomial1D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psDPolynomial1D_coeffErr_set;
*swig_mask_get = *pslibc::psDPolynomial1D_mask_get;
*swig_mask_set = *pslibc::psDPolynomial1D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psDPolynomial1D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psDPolynomial1D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psDPolynomial2D ##############

package pslib::psDPolynomial2D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psDPolynomial2D_type_get;
*swig_type_set = *pslibc::psDPolynomial2D_type_set;
*swig_nX_get = *pslibc::psDPolynomial2D_nX_get;
*swig_nX_set = *pslibc::psDPolynomial2D_nX_set;
*swig_nY_get = *pslibc::psDPolynomial2D_nY_get;
*swig_nY_set = *pslibc::psDPolynomial2D_nY_set;
*swig_coeff_get = *pslibc::psDPolynomial2D_coeff_get;
*swig_coeff_set = *pslibc::psDPolynomial2D_coeff_set;
*swig_coeffErr_get = *pslibc::psDPolynomial2D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psDPolynomial2D_coeffErr_set;
*swig_mask_get = *pslibc::psDPolynomial2D_mask_get;
*swig_mask_set = *pslibc::psDPolynomial2D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psDPolynomial2D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psDPolynomial2D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psDPolynomial3D ##############

package pslib::psDPolynomial3D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psDPolynomial3D_type_get;
*swig_type_set = *pslibc::psDPolynomial3D_type_set;
*swig_nX_get = *pslibc::psDPolynomial3D_nX_get;
*swig_nX_set = *pslibc::psDPolynomial3D_nX_set;
*swig_nY_get = *pslibc::psDPolynomial3D_nY_get;
*swig_nY_set = *pslibc::psDPolynomial3D_nY_set;
*swig_nZ_get = *pslibc::psDPolynomial3D_nZ_get;
*swig_nZ_set = *pslibc::psDPolynomial3D_nZ_set;
*swig_coeff_get = *pslibc::psDPolynomial3D_coeff_get;
*swig_coeff_set = *pslibc::psDPolynomial3D_coeff_set;
*swig_coeffErr_get = *pslibc::psDPolynomial3D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psDPolynomial3D_coeffErr_set;
*swig_mask_get = *pslibc::psDPolynomial3D_mask_get;
*swig_mask_set = *pslibc::psDPolynomial3D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psDPolynomial3D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psDPolynomial3D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psDPolynomial4D ##############

package pslib::psDPolynomial4D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psDPolynomial4D_type_get;
*swig_type_set = *pslibc::psDPolynomial4D_type_set;
*swig_nW_get = *pslibc::psDPolynomial4D_nW_get;
*swig_nW_set = *pslibc::psDPolynomial4D_nW_set;
*swig_nX_get = *pslibc::psDPolynomial4D_nX_get;
*swig_nX_set = *pslibc::psDPolynomial4D_nX_set;
*swig_nY_get = *pslibc::psDPolynomial4D_nY_get;
*swig_nY_set = *pslibc::psDPolynomial4D_nY_set;
*swig_nZ_get = *pslibc::psDPolynomial4D_nZ_get;
*swig_nZ_set = *pslibc::psDPolynomial4D_nZ_set;
*swig_coeff_get = *pslibc::psDPolynomial4D_coeff_get;
*swig_coeff_set = *pslibc::psDPolynomial4D_coeff_set;
*swig_coeffErr_get = *pslibc::psDPolynomial4D_coeffErr_get;
*swig_coeffErr_set = *pslibc::psDPolynomial4D_coeffErr_set;
*swig_mask_get = *pslibc::psDPolynomial4D_mask_get;
*swig_mask_set = *pslibc::psDPolynomial4D_mask_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psDPolynomial4D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psDPolynomial4D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psSpline1D ##############

package pslib::psSpline1D;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_n_get = *pslibc::psSpline1D_n_get;
*swig_n_set = *pslibc::psSpline1D_n_set;
*swig_spline_get = *pslibc::psSpline1D_spline_get;
*swig_spline_set = *pslibc::psSpline1D_spline_set;
*swig_p_psDeriv2_get = *pslibc::psSpline1D_p_psDeriv2_get;
*swig_p_psDeriv2_set = *pslibc::psSpline1D_p_psDeriv2_set;
*swig_domains_get = *pslibc::psSpline1D_domains_get;
*swig_domains_set = *pslibc::psSpline1D_domains_set;
*swig_knots_get = *pslibc::psSpline1D_knots_get;
*swig_knots_set = *pslibc::psSpline1D_knots_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psSpline1D(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psSpline1D($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMinimization ##############

package pslib::psMinimization;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_maxIter_get = *pslibc::psMinimization_maxIter_get;
*swig_maxIter_set = *pslibc::psMinimization_maxIter_set;
*swig_tol_get = *pslibc::psMinimization_tol_get;
*swig_tol_set = *pslibc::psMinimization_tol_set;
*swig_value_get = *pslibc::psMinimization_value_get;
*swig_value_set = *pslibc::psMinimization_value_set;
*swig_iter_get = *pslibc::psMinimization_iter_get;
*swig_iter_set = *pslibc::psMinimization_iter_set;
*swig_lastDelta_get = *pslibc::psMinimization_lastDelta_get;
*swig_lastDelta_set = *pslibc::psMinimization_lastDelta_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMinimization(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMinimization($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psRandom ##############

package pslib::psRandom;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psRandom_type_get;
*swig_type_set = *pslibc::psRandom_type_set;
*swig_gsl_get = *pslibc::psRandom_gsl_get;
*swig_gsl_set = *pslibc::psRandom_gsl_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psRandom(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psRandom($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psStats ##############

package pslib::psStats;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_sampleMean_get = *pslibc::psStats_sampleMean_get;
*swig_sampleMean_set = *pslibc::psStats_sampleMean_set;
*swig_sampleMedian_get = *pslibc::psStats_sampleMedian_get;
*swig_sampleMedian_set = *pslibc::psStats_sampleMedian_set;
*swig_sampleStdev_get = *pslibc::psStats_sampleStdev_get;
*swig_sampleStdev_set = *pslibc::psStats_sampleStdev_set;
*swig_sampleUQ_get = *pslibc::psStats_sampleUQ_get;
*swig_sampleUQ_set = *pslibc::psStats_sampleUQ_set;
*swig_sampleLQ_get = *pslibc::psStats_sampleLQ_get;
*swig_sampleLQ_set = *pslibc::psStats_sampleLQ_set;
*swig_robustMean_get = *pslibc::psStats_robustMean_get;
*swig_robustMean_set = *pslibc::psStats_robustMean_set;
*swig_robustMedian_get = *pslibc::psStats_robustMedian_get;
*swig_robustMedian_set = *pslibc::psStats_robustMedian_set;
*swig_robustMode_get = *pslibc::psStats_robustMode_get;
*swig_robustMode_set = *pslibc::psStats_robustMode_set;
*swig_robustStdev_get = *pslibc::psStats_robustStdev_get;
*swig_robustStdev_set = *pslibc::psStats_robustStdev_set;
*swig_robustUQ_get = *pslibc::psStats_robustUQ_get;
*swig_robustUQ_set = *pslibc::psStats_robustUQ_set;
*swig_robustLQ_get = *pslibc::psStats_robustLQ_get;
*swig_robustLQ_set = *pslibc::psStats_robustLQ_set;
*swig_robustN50_get = *pslibc::psStats_robustN50_get;
*swig_robustN50_set = *pslibc::psStats_robustN50_set;
*swig_robustNfit_get = *pslibc::psStats_robustNfit_get;
*swig_robustNfit_set = *pslibc::psStats_robustNfit_set;
*swig_clippedMean_get = *pslibc::psStats_clippedMean_get;
*swig_clippedMean_set = *pslibc::psStats_clippedMean_set;
*swig_clippedStdev_get = *pslibc::psStats_clippedStdev_get;
*swig_clippedStdev_set = *pslibc::psStats_clippedStdev_set;
*swig_clippedNvalues_get = *pslibc::psStats_clippedNvalues_get;
*swig_clippedNvalues_set = *pslibc::psStats_clippedNvalues_set;
*swig_clipSigma_get = *pslibc::psStats_clipSigma_get;
*swig_clipSigma_set = *pslibc::psStats_clipSigma_set;
*swig_clipIter_get = *pslibc::psStats_clipIter_get;
*swig_clipIter_set = *pslibc::psStats_clipIter_set;
*swig_min_get = *pslibc::psStats_min_get;
*swig_min_set = *pslibc::psStats_min_set;
*swig_max_get = *pslibc::psStats_max_get;
*swig_max_set = *pslibc::psStats_max_set;
*swig_binsize_get = *pslibc::psStats_binsize_get;
*swig_binsize_set = *pslibc::psStats_binsize_set;
*swig_options_get = *pslibc::psStats_options_get;
*swig_options_set = *pslibc::psStats_options_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psStats(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psStats($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psHistogram ##############

package pslib::psHistogram;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_bounds_get = *pslibc::psHistogram_bounds_get;
*swig_bounds_set = *pslibc::psHistogram_bounds_set;
*swig_nums_get = *pslibc::psHistogram_nums_get;
*swig_nums_set = *pslibc::psHistogram_nums_set;
*swig_minNum_get = *pslibc::psHistogram_minNum_get;
*swig_minNum_set = *pslibc::psHistogram_minNum_set;
*swig_maxNum_get = *pslibc::psHistogram_maxNum_get;
*swig_maxNum_set = *pslibc::psHistogram_maxNum_set;
*swig_uniform_get = *pslibc::psHistogram_uniform_get;
*swig_uniform_set = *pslibc::psHistogram_uniform_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psHistogram(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psHistogram($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psArray ##############

package pslib::psArray;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_nalloc_get = *pslibc::psArray_nalloc_get;
*swig_nalloc_set = *pslibc::psArray_nalloc_set;
*swig_n_get = *pslibc::psArray_n_get;
*swig_n_set = *pslibc::psArray_n_set;
*swig_data_get = *pslibc::psArray_data_get;
*swig_data_set = *pslibc::psArray_data_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psArray(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psArray($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psBitSet ##############

package pslib::psBitSet;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_n_get = *pslibc::psBitSet_n_get;
*swig_n_set = *pslibc::psBitSet_n_set;
*swig_bits_get = *pslibc::psBitSet_bits_get;
*swig_bits_set = *pslibc::psBitSet_bits_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psBitSet(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psBitSet($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psHashBucket ##############

package pslib::psHashBucket;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_key_get = *pslibc::psHashBucket_key_get;
*swig_key_set = *pslibc::psHashBucket_key_set;
*swig_data_get = *pslibc::psHashBucket_data_get;
*swig_data_set = *pslibc::psHashBucket_data_set;
*swig_next_get = *pslibc::psHashBucket_next_get;
*swig_next_set = *pslibc::psHashBucket_next_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psHashBucket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psHashBucket($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psHash ##############

package pslib::psHash;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_nbucket_get = *pslibc::psHash_nbucket_get;
*swig_nbucket_set = *pslibc::psHash_nbucket_set;
*swig_buckets_get = *pslibc::psHash_buckets_get;
*swig_buckets_set = *pslibc::psHash_buckets_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psHash(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psHash($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psListElem ##############

package pslib::psListElem;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_prev_get = *pslibc::psListElem_prev_get;
*swig_prev_set = *pslibc::psListElem_prev_set;
*swig_next_get = *pslibc::psListElem_next_get;
*swig_next_set = *pslibc::psListElem_next_set;
*swig_data_get = *pslibc::psListElem_data_get;
*swig_data_set = *pslibc::psListElem_data_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psListElem(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psListElem($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psList ##############

package pslib::psList;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *pslibc::psList_size_get;
*swig_size_set = *pslibc::psList_size_set;
*swig_head_get = *pslibc::psList_head_get;
*swig_head_set = *pslibc::psList_head_set;
*swig_tail_get = *pslibc::psList_tail_get;
*swig_tail_set = *pslibc::psList_tail_set;
*swig_iterators_get = *pslibc::psList_iterators_get;
*swig_iterators_set = *pslibc::psList_iterators_set;
*swig_lock_get = *pslibc::psList_lock_get;
*swig_lock_set = *pslibc::psList_lock_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psList($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psListIterator ##############

package pslib::psListIterator;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_list_get = *pslibc::psListIterator_list_get;
*swig_list_set = *pslibc::psListIterator_list_set;
*swig_cursor_get = *pslibc::psListIterator_cursor_get;
*swig_cursor_set = *pslibc::psListIterator_cursor_set;
*swig_index_get = *pslibc::psListIterator_index_get;
*swig_index_set = *pslibc::psListIterator_index_set;
*swig_offEnd_get = *pslibc::psListIterator_offEnd_get;
*swig_offEnd_set = *pslibc::psListIterator_offEnd_set;
*swig_mutable_get = *pslibc::psListIterator_mutable_get;
*swig_mutable_set = *pslibc::psListIterator_mutable_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psListIterator(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psListIterator($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psScalar ##############

package pslib::psScalar;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psScalar_type_get;
*swig_type_set = *pslibc::psScalar_type_set;
*swig_data_get = *pslibc::psScalar_data_get;
*swig_data_set = *pslibc::psScalar_data_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psScalar(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psScalar($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psScalar_data ##############

package pslib::psScalar_data;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_U8_get = *pslibc::psScalar_data_U8_get;
*swig_U8_set = *pslibc::psScalar_data_U8_set;
*swig_U16_get = *pslibc::psScalar_data_U16_get;
*swig_U16_set = *pslibc::psScalar_data_U16_set;
*swig_U32_get = *pslibc::psScalar_data_U32_get;
*swig_U32_set = *pslibc::psScalar_data_U32_set;
*swig_U64_get = *pslibc::psScalar_data_U64_get;
*swig_U64_set = *pslibc::psScalar_data_U64_set;
*swig_S8_get = *pslibc::psScalar_data_S8_get;
*swig_S8_set = *pslibc::psScalar_data_S8_set;
*swig_S16_get = *pslibc::psScalar_data_S16_get;
*swig_S16_set = *pslibc::psScalar_data_S16_set;
*swig_S32_get = *pslibc::psScalar_data_S32_get;
*swig_S32_set = *pslibc::psScalar_data_S32_set;
*swig_S64_get = *pslibc::psScalar_data_S64_get;
*swig_S64_set = *pslibc::psScalar_data_S64_set;
*swig_F32_get = *pslibc::psScalar_data_F32_get;
*swig_F32_set = *pslibc::psScalar_data_F32_set;
*swig_F64_get = *pslibc::psScalar_data_F64_get;
*swig_F64_set = *pslibc::psScalar_data_F64_set;
*swig_C32_get = *pslibc::psScalar_data_C32_get;
*swig_C32_set = *pslibc::psScalar_data_C32_set;
*swig_C64_get = *pslibc::psScalar_data_C64_get;
*swig_C64_set = *pslibc::psScalar_data_C64_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psScalar_data(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psScalar_data($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psVector ##############

package pslib::psVector;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_type_get = *pslibc::psVector_type_get;
*swig_type_set = *pslibc::psVector_type_set;
*swig_nalloc_get = *pslibc::psVector_nalloc_get;
*swig_nalloc_set = *pslibc::psVector_nalloc_set;
*swig_n_get = *pslibc::psVector_n_get;
*swig_n_set = *pslibc::psVector_n_set;
*swig_data_get = *pslibc::psVector_data_get;
*swig_data_set = *pslibc::psVector_data_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psVector(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psVector($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psVector_data ##############

package pslib::psVector_data;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_U8_get = *pslibc::psVector_data_U8_get;
*swig_U8_set = *pslibc::psVector_data_U8_set;
*swig_U16_get = *pslibc::psVector_data_U16_get;
*swig_U16_set = *pslibc::psVector_data_U16_set;
*swig_U32_get = *pslibc::psVector_data_U32_get;
*swig_U32_set = *pslibc::psVector_data_U32_set;
*swig_U64_get = *pslibc::psVector_data_U64_get;
*swig_U64_set = *pslibc::psVector_data_U64_set;
*swig_S8_get = *pslibc::psVector_data_S8_get;
*swig_S8_set = *pslibc::psVector_data_S8_set;
*swig_S16_get = *pslibc::psVector_data_S16_get;
*swig_S16_set = *pslibc::psVector_data_S16_set;
*swig_S32_get = *pslibc::psVector_data_S32_get;
*swig_S32_set = *pslibc::psVector_data_S32_set;
*swig_S64_get = *pslibc::psVector_data_S64_get;
*swig_S64_set = *pslibc::psVector_data_S64_set;
*swig_F32_get = *pslibc::psVector_data_F32_get;
*swig_F32_set = *pslibc::psVector_data_F32_set;
*swig_F64_get = *pslibc::psVector_data_F64_get;
*swig_F64_set = *pslibc::psVector_data_F64_set;
*swig_C32_get = *pslibc::psVector_data_C32_get;
*swig_C32_set = *pslibc::psVector_data_C32_set;
*swig_C64_get = *pslibc::psVector_data_C64_get;
*swig_C64_set = *pslibc::psVector_data_C64_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psVector_data(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psVector_data($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psGrommit ##############

package pslib::psGrommit;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_latitude_get = *pslibc::psGrommit_latitude_get;
*swig_latitude_set = *pslibc::psGrommit_latitude_set;
*swig_sinLat_get = *pslibc::psGrommit_sinLat_get;
*swig_sinLat_set = *pslibc::psGrommit_sinLat_set;
*swig_cosLat_get = *pslibc::psGrommit_cosLat_get;
*swig_cosLat_set = *pslibc::psGrommit_cosLat_set;
*swig_abberationMag_get = *pslibc::psGrommit_abberationMag_get;
*swig_abberationMag_set = *pslibc::psGrommit_abberationMag_set;
*swig_height_get = *pslibc::psGrommit_height_get;
*swig_height_set = *pslibc::psGrommit_height_set;
*swig_temperature_get = *pslibc::psGrommit_temperature_get;
*swig_temperature_set = *pslibc::psGrommit_temperature_set;
*swig_pressure_get = *pslibc::psGrommit_pressure_get;
*swig_pressure_set = *pslibc::psGrommit_pressure_set;
*swig_humidity_get = *pslibc::psGrommit_humidity_get;
*swig_humidity_set = *pslibc::psGrommit_humidity_set;
*swig_wavelength_get = *pslibc::psGrommit_wavelength_get;
*swig_wavelength_set = *pslibc::psGrommit_wavelength_set;
*swig_lapseRate_get = *pslibc::psGrommit_lapseRate_get;
*swig_lapseRate_set = *pslibc::psGrommit_lapseRate_set;
*swig_refractA_get = *pslibc::psGrommit_refractA_get;
*swig_refractA_set = *pslibc::psGrommit_refractA_set;
*swig_refractB_get = *pslibc::psGrommit_refractB_get;
*swig_refractB_set = *pslibc::psGrommit_refractB_set;
*swig_longitudeOffset_get = *pslibc::psGrommit_longitudeOffset_get;
*swig_longitudeOffset_set = *pslibc::psGrommit_longitudeOffset_set;
*swig_siderealTime_get = *pslibc::psGrommit_siderealTime_get;
*swig_siderealTime_set = *pslibc::psGrommit_siderealTime_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psGrommit(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psGrommit($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psFixedPattern ##############

package pslib::psFixedPattern;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_nX_get = *pslibc::psFixedPattern_nX_get;
*swig_nX_set = *pslibc::psFixedPattern_nX_set;
*swig_nY_get = *pslibc::psFixedPattern_nY_get;
*swig_nY_set = *pslibc::psFixedPattern_nY_set;
*swig_x0_get = *pslibc::psFixedPattern_x0_get;
*swig_x0_set = *pslibc::psFixedPattern_x0_set;
*swig_y0_get = *pslibc::psFixedPattern_y0_get;
*swig_y0_set = *pslibc::psFixedPattern_y0_set;
*swig_xScale_get = *pslibc::psFixedPattern_xScale_get;
*swig_xScale_set = *pslibc::psFixedPattern_xScale_set;
*swig_yScale_get = *pslibc::psFixedPattern_yScale_get;
*swig_yScale_set = *pslibc::psFixedPattern_yScale_set;
*swig_p_ps_xRows_get = *pslibc::psFixedPattern_p_ps_xRows_get;
*swig_p_ps_xRows_set = *pslibc::psFixedPattern_p_ps_xRows_set;
*swig_p_ps_xCols_get = *pslibc::psFixedPattern_p_ps_xCols_get;
*swig_p_ps_xCols_set = *pslibc::psFixedPattern_p_ps_xCols_set;
*swig_p_ps_yRows_get = *pslibc::psFixedPattern_p_ps_yRows_get;
*swig_p_ps_yRows_set = *pslibc::psFixedPattern_p_ps_yRows_set;
*swig_p_ps_yCols_get = *pslibc::psFixedPattern_p_ps_yCols_get;
*swig_p_ps_yCols_set = *pslibc::psFixedPattern_p_ps_yCols_set;
*swig_x_get = *pslibc::psFixedPattern_x_get;
*swig_x_set = *pslibc::psFixedPattern_x_set;
*swig_y_get = *pslibc::psFixedPattern_y_get;
*swig_y_set = *pslibc::psFixedPattern_y_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psFixedPattern(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psFixedPattern($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psReadout ##############

package pslib::psReadout;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_col0_get = *pslibc::psReadout_col0_get;
*swig_col0_set = *pslibc::psReadout_col0_set;
*swig_row0_get = *pslibc::psReadout_row0_get;
*swig_row0_set = *pslibc::psReadout_row0_set;
*swig_colParity_get = *pslibc::psReadout_colParity_get;
*swig_colParity_set = *pslibc::psReadout_colParity_set;
*swig_rowParity_get = *pslibc::psReadout_rowParity_get;
*swig_rowParity_set = *pslibc::psReadout_rowParity_set;
*swig_colBins_get = *pslibc::psReadout_colBins_get;
*swig_colBins_set = *pslibc::psReadout_colBins_set;
*swig_rowBins_get = *pslibc::psReadout_rowBins_get;
*swig_rowBins_set = *pslibc::psReadout_rowBins_set;
*swig_image_get = *pslibc::psReadout_image_get;
*swig_image_set = *pslibc::psReadout_image_set;
*swig_mask_get = *pslibc::psReadout_mask_get;
*swig_mask_set = *pslibc::psReadout_mask_set;
*swig_objects_get = *pslibc::psReadout_objects_get;
*swig_objects_set = *pslibc::psReadout_objects_set;
*swig_metadata_get = *pslibc::psReadout_metadata_get;
*swig_metadata_set = *pslibc::psReadout_metadata_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psReadout(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psReadout($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psCell ##############

package pslib::psCell;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_col0_get = *pslibc::psCell_col0_get;
*swig_col0_set = *pslibc::psCell_col0_set;
*swig_row0_get = *pslibc::psCell_row0_get;
*swig_row0_set = *pslibc::psCell_row0_set;
*swig_readouts_get = *pslibc::psCell_readouts_get;
*swig_readouts_set = *pslibc::psCell_readouts_set;
*swig_metadata_get = *pslibc::psCell_metadata_get;
*swig_metadata_set = *pslibc::psCell_metadata_set;
*swig_toChip_get = *pslibc::psCell_toChip_get;
*swig_toChip_set = *pslibc::psCell_toChip_set;
*swig_fromChip_get = *pslibc::psCell_fromChip_get;
*swig_fromChip_set = *pslibc::psCell_fromChip_set;
*swig_toFPA_get = *pslibc::psCell_toFPA_get;
*swig_toFPA_set = *pslibc::psCell_toFPA_set;
*swig_toTP_get = *pslibc::psCell_toTP_get;
*swig_toTP_set = *pslibc::psCell_toTP_set;
*swig_toSky_get = *pslibc::psCell_toSky_get;
*swig_toSky_set = *pslibc::psCell_toSky_set;
*swig_parent_get = *pslibc::psCell_parent_get;
*swig_parent_set = *pslibc::psCell_parent_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psCell(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psCell($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psChip ##############

package pslib::psChip;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_col0_get = *pslibc::psChip_col0_get;
*swig_col0_set = *pslibc::psChip_col0_set;
*swig_row0_get = *pslibc::psChip_row0_get;
*swig_row0_set = *pslibc::psChip_row0_set;
*swig_cells_get = *pslibc::psChip_cells_get;
*swig_cells_set = *pslibc::psChip_cells_set;
*swig_metadata_get = *pslibc::psChip_metadata_get;
*swig_metadata_set = *pslibc::psChip_metadata_set;
*swig_toFPA_get = *pslibc::psChip_toFPA_get;
*swig_toFPA_set = *pslibc::psChip_toFPA_set;
*swig_fromFPA_get = *pslibc::psChip_fromFPA_get;
*swig_fromFPA_set = *pslibc::psChip_fromFPA_set;
*swig_parent_get = *pslibc::psChip_parent_get;
*swig_parent_set = *pslibc::psChip_parent_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psChip(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psChip($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psFPA ##############

package pslib::psFPA;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_chips_get = *pslibc::psFPA_chips_get;
*swig_chips_set = *pslibc::psFPA_chips_set;
*swig_metadata_get = *pslibc::psFPA_metadata_get;
*swig_metadata_set = *pslibc::psFPA_metadata_set;
*swig_fromTangentPlane_get = *pslibc::psFPA_fromTangentPlane_get;
*swig_fromTangentPlane_set = *pslibc::psFPA_fromTangentPlane_set;
*swig_toTangentPlane_get = *pslibc::psFPA_toTangentPlane_get;
*swig_toTangentPlane_set = *pslibc::psFPA_toTangentPlane_set;
*swig_pattern_get = *pslibc::psFPA_pattern_get;
*swig_pattern_set = *pslibc::psFPA_pattern_set;
*swig_exposure_get = *pslibc::psFPA_exposure_get;
*swig_exposure_set = *pslibc::psFPA_exposure_set;
*swig_grommit_get = *pslibc::psFPA_grommit_get;
*swig_grommit_set = *pslibc::psFPA_grommit_set;
*swig_colorPlus_get = *pslibc::psFPA_colorPlus_get;
*swig_colorPlus_set = *pslibc::psFPA_colorPlus_set;
*swig_colorMinus_get = *pslibc::psFPA_colorMinus_get;
*swig_colorMinus_set = *pslibc::psFPA_colorMinus_set;
*swig_projection_get = *pslibc::psFPA_projection_get;
*swig_projection_set = *pslibc::psFPA_projection_set;
*swig_rmsX_get = *pslibc::psFPA_rmsX_get;
*swig_rmsX_set = *pslibc::psFPA_rmsX_set;
*swig_rmsY_get = *pslibc::psFPA_rmsY_get;
*swig_rmsY_set = *pslibc::psFPA_rmsY_set;
*swig_chi2_get = *pslibc::psFPA_chi2_get;
*swig_chi2_set = *pslibc::psFPA_chi2_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psFPA(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psFPA($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psObservatory ##############

package pslib::psObservatory;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_name_get = *pslibc::psObservatory_name_get;
*swig_name_set = *pslibc::psObservatory_name_set;
*swig_latitude_get = *pslibc::psObservatory_latitude_get;
*swig_latitude_set = *pslibc::psObservatory_latitude_set;
*swig_longitude_get = *pslibc::psObservatory_longitude_get;
*swig_longitude_set = *pslibc::psObservatory_longitude_set;
*swig_height_get = *pslibc::psObservatory_height_get;
*swig_height_set = *pslibc::psObservatory_height_set;
*swig_tlr_get = *pslibc::psObservatory_tlr_get;
*swig_tlr_set = *pslibc::psObservatory_tlr_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psObservatory(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psObservatory($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psExposure ##############

package pslib::psExposure;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_ra_get = *pslibc::psExposure_ra_get;
*swig_ra_set = *pslibc::psExposure_ra_set;
*swig_dec_get = *pslibc::psExposure_dec_get;
*swig_dec_set = *pslibc::psExposure_dec_set;
*swig_hourAngle_get = *pslibc::psExposure_hourAngle_get;
*swig_hourAngle_set = *pslibc::psExposure_hourAngle_set;
*swig_zenithDistance_get = *pslibc::psExposure_zenithDistance_get;
*swig_zenithDistance_set = *pslibc::psExposure_zenithDistance_set;
*swig_azimuth_get = *pslibc::psExposure_azimuth_get;
*swig_azimuth_set = *pslibc::psExposure_azimuth_set;
*swig_time_get = *pslibc::psExposure_time_get;
*swig_time_set = *pslibc::psExposure_time_set;
*swig_rotAngle_get = *pslibc::psExposure_rotAngle_get;
*swig_rotAngle_set = *pslibc::psExposure_rotAngle_set;
*swig_temperature_get = *pslibc::psExposure_temperature_get;
*swig_temperature_set = *pslibc::psExposure_temperature_set;
*swig_pressure_get = *pslibc::psExposure_pressure_get;
*swig_pressure_set = *pslibc::psExposure_pressure_set;
*swig_humidity_get = *pslibc::psExposure_humidity_get;
*swig_humidity_set = *pslibc::psExposure_humidity_set;
*swig_exposureTime_get = *pslibc::psExposure_exposureTime_get;
*swig_exposureTime_set = *pslibc::psExposure_exposureTime_set;
*swig_wavelength_get = *pslibc::psExposure_wavelength_get;
*swig_wavelength_set = *pslibc::psExposure_wavelength_set;
*swig_observatory_get = *pslibc::psExposure_observatory_get;
*swig_observatory_set = *pslibc::psExposure_observatory_set;
*swig_lst_get = *pslibc::psExposure_lst_get;
*swig_lst_set = *pslibc::psExposure_lst_set;
*swig_positionAngle_get = *pslibc::psExposure_positionAngle_get;
*swig_positionAngle_set = *pslibc::psExposure_positionAngle_set;
*swig_parallacticAngle_get = *pslibc::psExposure_parallacticAngle_get;
*swig_parallacticAngle_set = *pslibc::psExposure_parallacticAngle_set;
*swig_airmass_get = *pslibc::psExposure_airmass_get;
*swig_airmass_set = *pslibc::psExposure_airmass_set;
*swig_parallacticFactor_get = *pslibc::psExposure_parallacticFactor_get;
*swig_parallacticFactor_set = *pslibc::psExposure_parallacticFactor_set;
*swig_cameraName_get = *pslibc::psExposure_cameraName_get;
*swig_cameraName_set = *pslibc::psExposure_cameraName_set;
*swig_telescopeName_get = *pslibc::psExposure_telescopeName_get;
*swig_telescopeName_set = *pslibc::psExposure_telescopeName_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psExposure(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psExposure($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPlane ##############

package pslib::psPlane;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *pslibc::psPlane_x_get;
*swig_x_set = *pslibc::psPlane_x_set;
*swig_y_get = *pslibc::psPlane_y_get;
*swig_y_set = *pslibc::psPlane_y_set;
*swig_xErr_get = *pslibc::psPlane_xErr_get;
*swig_xErr_set = *pslibc::psPlane_xErr_set;
*swig_yErr_get = *pslibc::psPlane_yErr_get;
*swig_yErr_set = *pslibc::psPlane_yErr_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPlane(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPlane($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psSphere ##############

package pslib::psSphere;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_r_get = *pslibc::psSphere_r_get;
*swig_r_set = *pslibc::psSphere_r_set;
*swig_d_get = *pslibc::psSphere_d_get;
*swig_d_set = *pslibc::psSphere_d_set;
*swig_rErr_get = *pslibc::psSphere_rErr_get;
*swig_rErr_set = *pslibc::psSphere_rErr_set;
*swig_dErr_get = *pslibc::psSphere_dErr_get;
*swig_dErr_set = *pslibc::psSphere_dErr_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psSphere(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psSphere($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPlaneTransform ##############

package pslib::psPlaneTransform;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *pslibc::psPlaneTransform_x_get;
*swig_x_set = *pslibc::psPlaneTransform_x_set;
*swig_y_get = *pslibc::psPlaneTransform_y_get;
*swig_y_set = *pslibc::psPlaneTransform_y_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPlaneTransform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPlaneTransform($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPlaneDistort ##############

package pslib::psPlaneDistort;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *pslibc::psPlaneDistort_x_get;
*swig_x_set = *pslibc::psPlaneDistort_x_set;
*swig_y_get = *pslibc::psPlaneDistort_y_get;
*swig_y_set = *pslibc::psPlaneDistort_y_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPlaneDistort(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPlaneDistort($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psSphereTransform ##############

package pslib::psSphereTransform;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_alphaP_get = *pslibc::psSphereTransform_alphaP_get;
*swig_alphaP_set = *pslibc::psSphereTransform_alphaP_set;
*swig_cosDeltaP_get = *pslibc::psSphereTransform_cosDeltaP_get;
*swig_cosDeltaP_set = *pslibc::psSphereTransform_cosDeltaP_set;
*swig_sinDeltaP_get = *pslibc::psSphereTransform_sinDeltaP_get;
*swig_sinDeltaP_set = *pslibc::psSphereTransform_sinDeltaP_set;
*swig_phiP_get = *pslibc::psSphereTransform_phiP_get;
*swig_phiP_set = *pslibc::psSphereTransform_phiP_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psSphereTransform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psSphereTransform($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psProjection ##############

package pslib::psProjection;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_R_get = *pslibc::psProjection_R_get;
*swig_R_set = *pslibc::psProjection_R_set;
*swig_D_get = *pslibc::psProjection_D_get;
*swig_D_set = *pslibc::psProjection_D_set;
*swig_Xs_get = *pslibc::psProjection_Xs_get;
*swig_Xs_set = *pslibc::psProjection_Xs_set;
*swig_Ys_get = *pslibc::psProjection_Ys_get;
*swig_Ys_set = *pslibc::psProjection_Ys_set;
*swig_type_get = *pslibc::psProjection_type_get;
*swig_type_set = *pslibc::psProjection_type_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psProjection(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psProjection($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMetadata ##############

package pslib::psMetadata;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_list_get = *pslibc::psMetadata_list_get;
*swig_list_set = *pslibc::psMetadata_list_set;
*swig_table_get = *pslibc::psMetadata_table_get;
*swig_table_set = *pslibc::psMetadata_table_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMetadata(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMetadata($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMetadataIterator ##############

package pslib::psMetadataIterator;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_iter_get = *pslibc::psMetadataIterator_iter_get;
*swig_iter_set = *pslibc::psMetadataIterator_iter_set;
*swig_preg_get = *pslibc::psMetadataIterator_preg_get;
*swig_preg_set = *pslibc::psMetadataIterator_preg_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMetadataIterator(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMetadataIterator($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMetadataItem ##############

package pslib::psMetadataItem;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_id_get = *pslibc::psMetadataItem_id_get;
*swig_id_set = *pslibc::psMetadataItem_id_set;
*swig_name_get = *pslibc::psMetadataItem_name_get;
*swig_name_set = *pslibc::psMetadataItem_name_set;
*swig_type_get = *pslibc::psMetadataItem_type_get;
*swig_type_set = *pslibc::psMetadataItem_type_set;
*swig_comment_get = *pslibc::psMetadataItem_comment_get;
*swig_comment_set = *pslibc::psMetadataItem_comment_set;
*swig_data_get = *pslibc::psMetadataItem_data_get;
*swig_data_set = *pslibc::psMetadataItem_data_set;
*get_STR = *pslibc::psMetadataItem_get_STR;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMetadataItem(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMetadataItem($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psMetadataItem_data ##############

package pslib::psMetadataItem_data;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_B_get = *pslibc::psMetadataItem_data_B_get;
*swig_B_set = *pslibc::psMetadataItem_data_B_set;
*swig_S32_get = *pslibc::psMetadataItem_data_S32_get;
*swig_S32_set = *pslibc::psMetadataItem_data_S32_set;
*swig_F32_get = *pslibc::psMetadataItem_data_F32_get;
*swig_F32_set = *pslibc::psMetadataItem_data_F32_set;
*swig_F64_get = *pslibc::psMetadataItem_data_F64_get;
*swig_F64_set = *pslibc::psMetadataItem_data_F64_set;
*swig_list_get = *pslibc::psMetadataItem_data_list_get;
*swig_list_set = *pslibc::psMetadataItem_data_list_set;
*swig_md_get = *pslibc::psMetadataItem_data_md_get;
*swig_md_set = *pslibc::psMetadataItem_data_md_set;
*swig_V_get = *pslibc::psMetadataItem_data_V_get;
*swig_V_set = *pslibc::psMetadataItem_data_V_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psMetadataItem_data(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psMetadataItem_data($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPhotSystem ##############

package pslib::psPhotSystem;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_ID_get = *pslibc::psPhotSystem_ID_get;
*swig_ID_set = *pslibc::psPhotSystem_ID_set;
*swig_name_get = *pslibc::psPhotSystem_name_get;
*swig_name_set = *pslibc::psPhotSystem_name_set;
*swig_camera_get = *pslibc::psPhotSystem_camera_get;
*swig_camera_set = *pslibc::psPhotSystem_camera_set;
*swig_filter_get = *pslibc::psPhotSystem_filter_get;
*swig_filter_set = *pslibc::psPhotSystem_filter_set;
*swig_detector_get = *pslibc::psPhotSystem_detector_get;
*swig_detector_set = *pslibc::psPhotSystem_detector_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPhotSystem(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPhotSystem($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psPhotTransform ##############

package pslib::psPhotTransform;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_src_get = *pslibc::psPhotTransform_src_get;
*swig_src_set = *pslibc::psPhotTransform_src_set;
*swig_dst_get = *pslibc::psPhotTransform_dst_get;
*swig_dst_set = *pslibc::psPhotTransform_dst_set;
*swig_pP_get = *pslibc::psPhotTransform_pP_get;
*swig_pP_set = *pslibc::psPhotTransform_pP_set;
*swig_pM_get = *pslibc::psPhotTransform_pM_get;
*swig_pM_set = *pslibc::psPhotTransform_pM_set;
*swig_sP_get = *pslibc::psPhotTransform_sP_get;
*swig_sP_set = *pslibc::psPhotTransform_sP_set;
*swig_sM_get = *pslibc::psPhotTransform_sM_get;
*swig_sM_set = *pslibc::psPhotTransform_sM_set;
*swig_pA_get = *pslibc::psPhotTransform_pA_get;
*swig_pA_set = *pslibc::psPhotTransform_pA_set;
*swig_sA_get = *pslibc::psPhotTransform_sA_get;
*swig_sA_set = *pslibc::psPhotTransform_sA_set;
*swig_transform_get = *pslibc::psPhotTransform_transform_get;
*swig_transform_set = *pslibc::psPhotTransform_transform_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psPhotTransform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psPhotTransform($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : pslib::psTime ##############

package pslib::psTime;
@ISA = qw( pslib );
%OWNER = ();
%ITERATORS = ();
*swig_sec_get = *pslibc::psTime_sec_get;
*swig_sec_set = *pslibc::psTime_sec_set;
*swig_usec_get = *pslibc::psTime_usec_get;
*swig_usec_set = *pslibc::psTime_usec_set;
*swig_type_get = *pslibc::psTime_type_get;
*swig_type_set = *pslibc::psTime_type_set;
sub new {
    my $pkg = shift;
    my $self = pslibc::new_psTime(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        pslibc::delete_psTime($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package pslib;

*PS_TYPE_S8 = *pslibc::PS_TYPE_S8;
*PS_TYPE_S16 = *pslibc::PS_TYPE_S16;
*PS_TYPE_S32 = *pslibc::PS_TYPE_S32;
*PS_TYPE_S64 = *pslibc::PS_TYPE_S64;
*PS_TYPE_U8 = *pslibc::PS_TYPE_U8;
*PS_TYPE_U16 = *pslibc::PS_TYPE_U16;
*PS_TYPE_U32 = *pslibc::PS_TYPE_U32;
*PS_TYPE_U64 = *pslibc::PS_TYPE_U64;
*PS_TYPE_F32 = *pslibc::PS_TYPE_F32;
*PS_TYPE_F64 = *pslibc::PS_TYPE_F64;
*PS_TYPE_C32 = *pslibc::PS_TYPE_C32;
*PS_TYPE_C64 = *pslibc::PS_TYPE_C64;
*PS_TYPE_BOOL = *pslibc::PS_TYPE_BOOL;
*PS_TYPE_PTR = *pslibc::PS_TYPE_PTR;
*PS_TYPE_MASK_NAME = *pslibc::PS_TYPE_MASK_NAME;
*PS_MIN_U8 = *pslibc::PS_MIN_U8;
*PS_MIN_U16 = *pslibc::PS_MIN_U16;
*PS_MIN_U32 = *pslibc::PS_MIN_U32;
*PS_MIN_U64 = *pslibc::PS_MIN_U64;
*PS_TYPE_BOOL_NAME = *pslibc::PS_TYPE_BOOL_NAME;
*PS_TYPE_S8_NAME = *pslibc::PS_TYPE_S8_NAME;
*PS_TYPE_S16_NAME = *pslibc::PS_TYPE_S16_NAME;
*PS_TYPE_S32_NAME = *pslibc::PS_TYPE_S32_NAME;
*PS_TYPE_S64_NAME = *pslibc::PS_TYPE_S64_NAME;
*PS_TYPE_U8_NAME = *pslibc::PS_TYPE_U8_NAME;
*PS_TYPE_U16_NAME = *pslibc::PS_TYPE_U16_NAME;
*PS_TYPE_U32_NAME = *pslibc::PS_TYPE_U32_NAME;
*PS_TYPE_U64_NAME = *pslibc::PS_TYPE_U64_NAME;
*PS_TYPE_F32_NAME = *pslibc::PS_TYPE_F32_NAME;
*PS_TYPE_F64_NAME = *pslibc::PS_TYPE_F64_NAME;
*PS_TYPE_C32_NAME = *pslibc::PS_TYPE_C32_NAME;
*PS_TYPE_C64_NAME = *pslibc::PS_TYPE_C64_NAME;
*PS_TYPE_PTR_NAME = *pslibc::PS_TYPE_PTR_NAME;
*PS_BADPIXEL_BITMASK = *pslibc::PS_BADPIXEL_BITMASK;
*PS_DIMEN_SCALAR = *pslibc::PS_DIMEN_SCALAR;
*PS_DIMEN_VECTOR = *pslibc::PS_DIMEN_VECTOR;
*PS_DIMEN_TRANSV = *pslibc::PS_DIMEN_TRANSV;
*PS_DIMEN_IMAGE = *pslibc::PS_DIMEN_IMAGE;
*PS_DIMEN_OTHER = *pslibc::PS_DIMEN_OTHER;
*PS_ERR_NONE = *pslibc::PS_ERR_NONE;
*PS_ERR_BASE = *pslibc::PS_ERR_BASE;
*PS_ERR_UNKNOWN = *pslibc::PS_ERR_UNKNOWN;
*PS_ERR_IO = *pslibc::PS_ERR_IO;
*PS_ERR_LOCATION_INVALID = *pslibc::PS_ERR_LOCATION_INVALID;
*PS_ERR_MEMORY_CORRUPTION = *pslibc::PS_ERR_MEMORY_CORRUPTION;
*PS_ERR_MEMORY_DEREF_USAGE = *pslibc::PS_ERR_MEMORY_DEREF_USAGE;
*PS_ERR_BAD_PARAMETER_VALUE = *pslibc::PS_ERR_BAD_PARAMETER_VALUE;
*PS_ERR_BAD_PARAMETER_TYPE = *pslibc::PS_ERR_BAD_PARAMETER_TYPE;
*PS_ERR_BAD_PARAMETER_NULL = *pslibc::PS_ERR_BAD_PARAMETER_NULL;
*PS_ERR_BAD_PARAMETER_SIZE = *pslibc::PS_ERR_BAD_PARAMETER_SIZE;
*PS_ERR_UNEXPECTED_NULL = *pslibc::PS_ERR_UNEXPECTED_NULL;
*PS_ERR_OS_CALL_FAILED = *pslibc::PS_ERR_OS_CALL_FAILED;
*PS_ERR_N_ERR_CLASSES = *pslibc::PS_ERR_N_ERR_CLASSES;
*PS_LOG_ABORT = *pslibc::PS_LOG_ABORT;
*PS_LOG_ERROR = *pslibc::PS_LOG_ERROR;
*PS_LOG_WARN = *pslibc::PS_LOG_WARN;
*PS_LOG_INFO = *pslibc::PS_LOG_INFO;
*PS_LOG_NONE = *pslibc::PS_LOG_NONE;
*PS_LOG_TO_STDERR = *pslibc::PS_LOG_TO_STDERR;
*PS_LOG_TO_STDOUT = *pslibc::PS_LOG_TO_STDOUT;
*PS_TRACE_H = *pslibc::PS_TRACE_H;
*PS_UNKNOWN_TRACE_LEVEL = *pslibc::PS_UNKNOWN_TRACE_LEVEL;
*PS_DEFAULT_TRACE_LEVEL = *pslibc::PS_DEFAULT_TRACE_LEVEL;
*PS_THE_OTHER_DEFAULT_TRACE_LEVEL = *pslibc::PS_THE_OTHER_DEFAULT_TRACE_LEVEL;
*PS_TYPE_KERNEL_NAME = *pslibc::PS_TYPE_KERNEL_NAME;
*PS_ERRORTEXT_psImage_AREA_NEGATIVE = *pslibc::PS_ERRORTEXT_psImage_AREA_NEGATIVE;
*PS_ERRORTEXT_psImage_NOT_AN_IMAGE = *pslibc::PS_ERRORTEXT_psImage_NOT_AN_IMAGE;
*PS_ERRORTEXT_psImage_IMAGE_NULL = *pslibc::PS_ERRORTEXT_psImage_IMAGE_NULL;
*PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID = *pslibc::PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID;
*PS_ERRORTEXT_psImage_REGION_NULL = *pslibc::PS_ERRORTEXT_psImage_REGION_NULL;
*PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID = *pslibc::PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID;
*PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED = *pslibc::PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED;
*PS_ERRORTEXT_psImage_SUBSECTION_NULL = *pslibc::PS_ERRORTEXT_psImage_SUBSECTION_NULL;
*PS_ERRORTEXT_psImage_SUBSECTION_INVALID = *pslibc::PS_ERRORTEXT_psImage_SUBSECTION_INVALID;
*PS_ERRORTEXT_psImage_NOT_PARENT = *pslibc::PS_ERRORTEXT_psImage_NOT_PARENT;
*PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED;
*PS_ERRORTEXT_psImage_SUBSET_ZERO_SIZE = *pslibc::PS_ERRORTEXT_psImage_SUBSET_ZERO_SIZE;
*PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE = *pslibc::PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE;
*PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE = *pslibc::PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE;
*PS_ERRORTEXT_psImage_BAD_STAT = *pslibc::PS_ERRORTEXT_psImage_BAD_STAT;
*PS_ERRORTEXT_psImage_NO_STAT_OPTIONS = *pslibc::PS_ERRORTEXT_psImage_NO_STAT_OPTIONS;
*PS_ERRORTEXT_psImage_STAT_NULL = *pslibc::PS_ERRORTEXT_psImage_STAT_NULL;
*PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID = *pslibc::PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID;
*PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE = *pslibc::PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE;
*PS_ERRORTEXT_psImage_nSamples_TOOSMALL = *pslibc::PS_ERRORTEXT_psImage_nSamples_TOOSMALL;
*PS_ERRORTEXT_psImage_LINE_NOT_IN_IMAGE = *pslibc::PS_ERRORTEXT_psImage_LINE_NOT_IN_IMAGE;
*PS_ERRORTEXT_psImage_RADII_VECTOR_NULL = *pslibc::PS_ERRORTEXT_psImage_RADII_VECTOR_NULL;
*PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE = *pslibc::PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE;
*PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL = *pslibc::PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL;
*PS_ERRORTEXT_psImageFFT_IMAGE_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImageFFT_IMAGE_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psImageFFT_REVERSE_NOT_COMPLEX = *pslibc::PS_ERRORTEXT_psImageFFT_REVERSE_NOT_COMPLEX;
*PS_ERRORTEXT_psImageFFT_FORWARD_NOT_REAL = *pslibc::PS_ERRORTEXT_psImageFFT_FORWARD_NOT_REAL;
*PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL = *pslibc::PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL;
*PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH;
*PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH = *pslibc::PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH;
*PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED;
*PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED;
*PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED;
*PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE = *pslibc::PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE;
*PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION = *pslibc::PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION;
*PS_ERRORTEXT_psImageIO_FILENAME_NULL = *pslibc::PS_ERRORTEXT_psImageIO_FILENAME_NULL;
*PS_ERRORTEXT_psImageIO_FILENAME_INVALID = *pslibc::PS_ERRORTEXT_psImageIO_FILENAME_INVALID;
*PS_ERRORTEXT_psImageIO_EXTNAME_INVALID = *pslibc::PS_ERRORTEXT_psImageIO_EXTNAME_INVALID;
*PS_ERRORTEXT_psImageIO_EXTNUM_INVALID = *pslibc::PS_ERRORTEXT_psImageIO_EXTNUM_INVALID;
*PS_ERRORTEXT_psImageIO_DATATYPE_UNKNOWN = *pslibc::PS_ERRORTEXT_psImageIO_DATATYPE_UNKNOWN;
*PS_ERRORTEXT_psImageIO_IMAGE_DIM_UNKNOWN = *pslibc::PS_ERRORTEXT_psImageIO_IMAGE_DIM_UNKNOWN;
*PS_ERRORTEXT_psImageIO_IMAGE_SIZE_UNKNOWN = *pslibc::PS_ERRORTEXT_psImageIO_IMAGE_SIZE_UNKNOWN;
*PS_ERRORTEXT_psImageIO_IMAGE_DIMENSION_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImageIO_IMAGE_DIMENSION_UNSUPPORTED;
*PS_ERRORTEXT_psImageIO_FITS_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImageIO_FITS_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psImageIO_READ_FAILED = *pslibc::PS_ERRORTEXT_psImageIO_READ_FAILED;
*PS_ERRORTEXT_psImageIO_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImageIO_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psImageIO_WRITE_EXTNUM_INVALID = *pslibc::PS_ERRORTEXT_psImageIO_WRITE_EXTNUM_INVALID;
*PS_ERRORTEXT_psImageIO_FILENAME_CREATE_FAILED = *pslibc::PS_ERRORTEXT_psImageIO_FILENAME_CREATE_FAILED;
*PS_ERRORTEXT_psImageIO_CREATE_EXTENSION_FAILED = *pslibc::PS_ERRORTEXT_psImageIO_CREATE_EXTENSION_FAILED;
*PS_ERRORTEXT_psImageIO_CREATE_HDU_FAILED = *pslibc::PS_ERRORTEXT_psImageIO_CREATE_HDU_FAILED;
*PS_ERRORTEXT_psImageIO_WRITE_FAILED = *pslibc::PS_ERRORTEXT_psImageIO_WRITE_FAILED;
*PS_ERRORTEXT_psImageManip_MAXMIN = *pslibc::PS_ERRORTEXT_psImageManip_MAXMIN;
*PS_ERRORTEXT_psImageManip_MAXMIN_REAL = *pslibc::PS_ERRORTEXT_psImageManip_MAXMIN_REAL;
*PS_ERRORTEXT_psImageManip_MAXMIN_IMAG = *pslibc::PS_ERRORTEXT_psImageManip_MAXMIN_IMAG;
*PS_ERRORTEXT_psImageManip_OPERATION_NULL = *pslibc::PS_ERRORTEXT_psImageManip_OPERATION_NULL;
*PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH;
*PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID = *pslibc::PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID;
*PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID = *pslibc::PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID;
*PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE = *pslibc::PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE;
*PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED;
*PS_ERRORTEXT_psImageConvolve_SHIFT_NULL = *pslibc::PS_ERRORTEXT_psImageConvolve_SHIFT_NULL;
*PS_ERRORTEXT_psImageConvolve_KERNEL_NULL = *pslibc::PS_ERRORTEXT_psImageConvolve_KERNEL_NULL;
*PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH;
*PS_ERRORTEXT_psImageConvolve_FFT_FAILED = *pslibc::PS_ERRORTEXT_psImageConvolve_FFT_FAILED;
*PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED = *pslibc::PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED;
*PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE = *pslibc::PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE;
*PS_ERRORTEXT_psImage_COEFF_NULL = *pslibc::PS_ERRORTEXT_psImage_COEFF_NULL;
*PS_ERRORTEXT_psImageManip_TRANSFORM_NULL = *pslibc::PS_ERRORTEXT_psImageManip_TRANSFORM_NULL;
*PS_CUT_X_POS = *pslibc::PS_CUT_X_POS;
*PS_CUT_X_NEG = *pslibc::PS_CUT_X_NEG;
*PS_CUT_Y_POS = *pslibc::PS_CUT_Y_POS;
*PS_CUT_Y_NEG = *pslibc::PS_CUT_Y_NEG;
*PS_INTERPOLATE_FLAT = *pslibc::PS_INTERPOLATE_FLAT;
*PS_INTERPOLATE_BILINEAR = *pslibc::PS_INTERPOLATE_BILINEAR;
*PS_INTERPOLATE_LANCZOS2 = *pslibc::PS_INTERPOLATE_LANCZOS2;
*PS_INTERPOLATE_LANCZOS3 = *pslibc::PS_INTERPOLATE_LANCZOS3;
*PS_INTERPOLATE_LANCZOS4 = *pslibc::PS_INTERPOLATE_LANCZOS4;
*PS_INTERPOLATE_BILINEAR_VARIANCE = *pslibc::PS_INTERPOLATE_BILINEAR_VARIANCE;
*PS_INTERPOLATE_LANCZOS2_VARIANCE = *pslibc::PS_INTERPOLATE_LANCZOS2_VARIANCE;
*PS_INTERPOLATE_LANCZOS3_VARIANCE = *pslibc::PS_INTERPOLATE_LANCZOS3_VARIANCE;
*PS_INTERPOLATE_LANCZOS4_VARIANCE = *pslibc::PS_INTERPOLATE_LANCZOS4_VARIANCE;
*PS_INTERPOLATE_NUM_MODES = *pslibc::PS_INTERPOLATE_NUM_MODES;
*PS_ERRORTEXT_psLookupTable_FILE_NOT_FOUND = *pslibc::PS_ERRORTEXT_psLookupTable_FILE_NOT_FOUND;
*PS_ERRORTEXT_psLookupTable_PARSE_VALUE = *pslibc::PS_ERRORTEXT_psLookupTable_PARSE_VALUE;
*PS_ERRORTEXT_psLookupTable_PARSE_TYPE = *pslibc::PS_ERRORTEXT_psLookupTable_PARSE_TYPE;
*PS_ERRORTEXT_psLookupTable_PARSE_GENERAL = *pslibc::PS_ERRORTEXT_psLookupTable_PARSE_GENERAL;
*PS_ERRORTEXT_psLookupTable_INTERPOLATE_HIGH = *pslibc::PS_ERRORTEXT_psLookupTable_INTERPOLATE_HIGH;
*PS_ERRORTEXT_psLookupTable_INTERPOLATE_LOW = *pslibc::PS_ERRORTEXT_psLookupTable_INTERPOLATE_LOW;
*PS_ERRORTEXT_psLookupTable_DIVIDE_BY_ZERO = *pslibc::PS_ERRORTEXT_psLookupTable_DIVIDE_BY_ZERO;
*PS_ERRORTEXT_psLookupTable_INVALID_TYPE = *pslibc::PS_ERRORTEXT_psLookupTable_INVALID_TYPE;
*PS_ERRORTEXT_psLookupTable_TABLE_INVALID = *pslibc::PS_ERRORTEXT_psLookupTable_TABLE_INVALID;
*PS_ERRORTEXT_psFits_NULL = *pslibc::PS_ERRORTEXT_psFits_NULL;
*PS_ERRORTEXT_psFits_FILENAME_INVALID = *pslibc::PS_ERRORTEXT_psFits_FILENAME_INVALID;
*PS_ERRORTEXT_psFits_FILENAME_NULL = *pslibc::PS_ERRORTEXT_psFits_FILENAME_NULL;
*PS_ERRORTEXT_psFits_EXTNAME_NULL = *pslibc::PS_ERRORTEXT_psFits_EXTNAME_NULL;
*PS_ERRORTEXT_psFits_EXTNAME_INVALID = *pslibc::PS_ERRORTEXT_psFits_EXTNAME_INVALID;
*PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED = *pslibc::PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED;
*PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED = *pslibc::PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED;
*PS_ERRORTEXT_psFits_GET_EXTNUM_FAILED = *pslibc::PS_ERRORTEXT_psFits_GET_EXTNUM_FAILED;
*PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED = *pslibc::PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED;
*PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED = *pslibc::PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED;
*PS_ERRORTEXT_psFits_GETNUMKEYS_FAILED = *pslibc::PS_ERRORTEXT_psFits_GETNUMKEYS_FAILED;
*PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED = *pslibc::PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED;
*PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED = *pslibc::PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED;
*PS_ERRORTEXT_psFits_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psFits_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psFits_CREATE_HDU_FAILED = *pslibc::PS_ERRORTEXT_psFits_CREATE_HDU_FAILED;
*PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED = *pslibc::PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED;
*PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE = *pslibc::PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE;
*PS_ERRORTEXT_psFits_NOT_TABLE_TYPE = *pslibc::PS_ERRORTEXT_psFits_NOT_TABLE_TYPE;
*PS_ERRORTEXT_psFits_TABLE_EMPTY = *pslibc::PS_ERRORTEXT_psFits_TABLE_EMPTY;
*PS_ERRORTEXT_psFits_CFITSIO_ERROR = *pslibc::PS_ERRORTEXT_psFits_CFITSIO_ERROR;
*PS_ERRORTEXT_psFits_METATYPE_INVALID = *pslibc::PS_ERRORTEXT_psFits_METATYPE_INVALID;
*PS_ERRORTEXT_psFits_METADATA_ADD_FAILED = *pslibc::PS_ERRORTEXT_psFits_METADATA_ADD_FAILED;
*PS_ERRORTEXT_psFits_WRITE_FAILED = *pslibc::PS_ERRORTEXT_psFits_WRITE_FAILED;
*PS_ERRORTEXT_psFits_IMAGE_NULL = *pslibc::PS_ERRORTEXT_psFits_IMAGE_NULL;
*PS_ERRORTEXT_psFits_METADATA_NULL = *pslibc::PS_ERRORTEXT_psFits_METADATA_NULL;
*PS_ERRORTEXT_psFits_METADATA_PTYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psFits_METADATA_PTYPE_UNSUPPORTED;
*PS_ERRORTEXT_psFits_ROW_INVALID = *pslibc::PS_ERRORTEXT_psFits_ROW_INVALID;
*PS_ERRORTEXT_psFits_GET_TABLE_ELEMENT = *pslibc::PS_ERRORTEXT_psFits_GET_TABLE_ELEMENT;
*PS_ERRORTEXT_psFits_FIND_COLUMN = *pslibc::PS_ERRORTEXT_psFits_FIND_COLUMN;
*PS_ERRORTEXT_psFits_GET_COLTYPE = *pslibc::PS_ERRORTEXT_psFits_GET_COLTYPE;
*PS_ERRORTEXT_psFits_TABLE_READ_COL = *pslibc::PS_ERRORTEXT_psFits_TABLE_READ_COL;
*PS_ERRORTEXT_psFits_DATATYPE_UNKNOWN = *pslibc::PS_ERRORTEXT_psFits_DATATYPE_UNKNOWN;
*PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN = *pslibc::PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN;
*PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED;
*PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN = *pslibc::PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN;
*PS_ERRORTEXT_psFits_FITS_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psFits_FITS_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psFits_READ_FAILED = *pslibc::PS_ERRORTEXT_psFits_READ_FAILED;
*PS_ERRORTEXT_psFits_IMAGE_UPDATE_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psFits_IMAGE_UPDATE_TYPE_MISMATCH;
*PS_ERRORTEXT_psFits_FITS_Z_SMALL = *pslibc::PS_ERRORTEXT_psFits_FITS_Z_SMALL;
*PS_FITS_TYPE_NONE = *pslibc::PS_FITS_TYPE_NONE;
*PS_FITS_TYPE_IMAGE = *pslibc::PS_FITS_TYPE_IMAGE;
*PS_FITS_TYPE_BINARY_TABLE = *pslibc::PS_FITS_TYPE_BINARY_TABLE;
*PS_FITS_TYPE_ASCII_TABLE = *pslibc::PS_FITS_TYPE_ASCII_TABLE;
*PS_FITS_TYPE_ANY = *pslibc::PS_FITS_TYPE_ANY;
*PS_LOOKUP_SUCCESS = *pslibc::PS_LOOKUP_SUCCESS;
*PS_LOOKUP_PAST_TOP = *pslibc::PS_LOOKUP_PAST_TOP;
*PS_LOOKUP_PAST_BOTTOM = *pslibc::PS_LOOKUP_PAST_BOTTOM;
*PS_LOOKUP_ERROR = *pslibc::PS_LOOKUP_ERROR;
*PS_PARSE_SUCCESS = *pslibc::PS_PARSE_SUCCESS;
*PS_PARSE_ERROR_TYPE = *pslibc::PS_PARSE_ERROR_TYPE;
*PS_PARSE_ERROR_VALUE = *pslibc::PS_PARSE_ERROR_VALUE;
*PS_PARSE_ERROR_GENERAL = *pslibc::PS_PARSE_ERROR_GENERAL;
*PS_DETERMINE_BRACKET_STEP_SIZE = *pslibc::PS_DETERMINE_BRACKET_STEP_SIZE;
*PS_MAX_LMM_ITERATIONS = *pslibc::PS_MAX_LMM_ITERATIONS;
*PS_MAX_MINIMIZE_ITERATIONS = *pslibc::PS_MAX_MINIMIZE_ITERATIONS;
*PS_LEFT_SPLINE_DERIV = *pslibc::PS_LEFT_SPLINE_DERIV;
*PS_RIGHT_SPLINE_DERIV = *pslibc::PS_RIGHT_SPLINE_DERIV;
*PS_ONE = *pslibc::PS_ONE;
*PS_PI = *pslibc::PS_PI;
*PS_PI_2 = *pslibc::PS_PI_2;
*PS_PI_4 = *pslibc::PS_PI_4;
*PS_1_PI = *pslibc::PS_1_PI;
*PS_2_PI = *pslibc::PS_2_PI;
*PS_ERRORTEXT_psVectorFFT_TYPE_NOT_F32_C32 = *pslibc::PS_ERRORTEXT_psVectorFFT_TYPE_NOT_F32_C32;
*PS_ERRORTEXT_psVectorFFT_REVERSE_NOT_COMPLEX = *pslibc::PS_ERRORTEXT_psVectorFFT_REVERSE_NOT_COMPLEX;
*PS_ERRORTEXT_psVectorFFT_FORWARD_NOT_REAL = *pslibc::PS_ERRORTEXT_psVectorFFT_FORWARD_NOT_REAL;
*PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL = *pslibc::PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL;
*PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH;
*PS_ERRORTEXT_psVectorFFT_REAL_IMAG_SIZE_MISMATCH = *pslibc::PS_ERRORTEXT_psVectorFFT_REAL_IMAG_SIZE_MISMATCH;
*PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED;
*PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED = *pslibc::PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED;
*PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET = *pslibc::PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET;
*PS_ERRORTEXT_psStats_NOT_F32_F64 = *pslibc::PS_ERRORTEXT_psStats_NOT_F32_F64;
*PS_ERRORTEXT_psStats_VECTOR_TYPE_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psStats_VECTOR_TYPE_UNSUPPORTED;
*PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE = *pslibc::PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE;
*PS_ERRORTEXT_psStats_ROBUST_QUARTILE_BINS_FAILED = *pslibc::PS_ERRORTEXT_psStats_ROBUST_QUARTILE_BINS_FAILED;
*PS_ERRORTEXT_psStats_STATS_FAILED = *pslibc::PS_ERRORTEXT_psStats_STATS_FAILED;
*PS_ERRORTEXT_psStats_STATS_SAMPLE_MEDIAN_SORT_PROBLEM = *pslibc::PS_ERRORTEXT_psStats_STATS_SAMPLE_MEDIAN_SORT_PROBLEM;
*PS_ERRORTEXT_psStats_STATS_VECTOR_BIN_DISECT_PROBLEM = *pslibc::PS_ERRORTEXT_psStats_STATS_VECTOR_BIN_DISECT_PROBLEM;
*PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLYNOMIAL_1D_FIT = *pslibc::PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLYNOMIAL_1D_FIT;
*PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLY_MEDIAN = *pslibc::PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLY_MEDIAN;
*PS_ERRORTEXT_psStats_ROBUST_STATS_CLIPPED_STATS = *pslibc::PS_ERRORTEXT_psStats_ROBUST_STATS_CLIPPED_STATS;
*PS_ERRORTEXT_psStats_STATS_POLY_MEDIAN_OUT_OF_RANGE = *pslibc::PS_ERRORTEXT_psStats_STATS_POLY_MEDIAN_OUT_OF_RANGE;
*PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE = *pslibc::PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE;
*PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED = *pslibc::PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED;
*PS_ERRORTEXT_psFunctions_NOT_ENOUGH_DATAPOINTS = *pslibc::PS_ERRORTEXT_psFunctions_NOT_ENOUGH_DATAPOINTS;
*PS_ERRORTEXT_psRandom_UNKNOWN_RANDFOM_NUMBER_GENERATOR_TYPE = *pslibc::PS_ERRORTEXT_psRandom_UNKNOWN_RANDFOM_NUMBER_GENERATOR_TYPE;
*PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR = *pslibc::PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR;
*PS_ERRORTEXT_psMatrix_COUNT_DIFFERS = *pslibc::PS_ERRORTEXT_psMatrix_COUNT_DIFFERS;
*PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS = *pslibc::PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS;
*PS_ERRORTEXT_psMatrix_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psMatrix_TYPE_MISMATCH;
*PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT = *pslibc::PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT;
*PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT = *pslibc::PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT;
*PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED = *pslibc::PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED;
*PS_ERRORTEXT_psMatrix_DIMEN_OTHER_FOUND = *pslibc::PS_ERRORTEXT_psMatrix_DIMEN_OTHER_FOUND;
*PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED = *pslibc::PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED;
*PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED = *pslibc::PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED;
*PS_ERRORTEXT_psMatrix_DIMEN_INVALID = *pslibc::PS_ERRORTEXT_psMatrix_DIMEN_INVALID;
*PS_ERRORTEXT_psMatrix_VECTOR_EMPTY = *pslibc::PS_ERRORTEXT_psMatrix_VECTOR_EMPTY;
*PS_ERRORTEXT_psMatrix_IMAGE_EMPTY = *pslibc::PS_ERRORTEXT_psMatrix_IMAGE_EMPTY;
*PS_ERRORTEXT_psMatrix_TRANSPOSE_MISMATCH = *pslibc::PS_ERRORTEXT_psMatrix_TRANSPOSE_MISMATCH;
*PS_POLYNOMIAL_ORD = *pslibc::PS_POLYNOMIAL_ORD;
*PS_POLYNOMIAL_CHEB = *pslibc::PS_POLYNOMIAL_CHEB;
*PS_RANDOM_TAUS = *pslibc::PS_RANDOM_TAUS;
*PS_STAT_SAMPLE_MEAN = *pslibc::PS_STAT_SAMPLE_MEAN;
*PS_STAT_SAMPLE_MEDIAN = *pslibc::PS_STAT_SAMPLE_MEDIAN;
*PS_STAT_SAMPLE_STDEV = *pslibc::PS_STAT_SAMPLE_STDEV;
*PS_STAT_SAMPLE_QUARTILE = *pslibc::PS_STAT_SAMPLE_QUARTILE;
*PS_STAT_ROBUST_MEAN = *pslibc::PS_STAT_ROBUST_MEAN;
*PS_STAT_ROBUST_MEDIAN = *pslibc::PS_STAT_ROBUST_MEDIAN;
*PS_STAT_ROBUST_MODE = *pslibc::PS_STAT_ROBUST_MODE;
*PS_STAT_ROBUST_STDEV = *pslibc::PS_STAT_ROBUST_STDEV;
*PS_STAT_ROBUST_QUARTILE = *pslibc::PS_STAT_ROBUST_QUARTILE;
*PS_STAT_CLIPPED_MEAN = *pslibc::PS_STAT_CLIPPED_MEAN;
*PS_STAT_CLIPPED_STDEV = *pslibc::PS_STAT_CLIPPED_STDEV;
*PS_STAT_MAX = *pslibc::PS_STAT_MAX;
*PS_STAT_MIN = *pslibc::PS_STAT_MIN;
*PS_STAT_USE_RANGE = *pslibc::PS_STAT_USE_RANGE;
*PS_STAT_USE_BINSIZE = *pslibc::PS_STAT_USE_BINSIZE;
*PS_STAT_ROBUST_FOR_SAMPLE = *pslibc::PS_STAT_ROBUST_FOR_SAMPLE;
*PS_FFT_FORWARD = *pslibc::PS_FFT_FORWARD;
*PS_FFT_REVERSE = *pslibc::PS_FFT_REVERSE;
*PS_FFT_REAL_RESULT = *pslibc::PS_FFT_REAL_RESULT;
*PS_ERRORNAME_DOMAIN = *pslibc::PS_ERRORNAME_DOMAIN;
*PS_ERRORTEXT_psArray_REALLOC_NULL = *pslibc::PS_ERRORTEXT_psArray_REALLOC_NULL;
*PS_ERRORTEXT_psArray_ARRAY_NULL = *pslibc::PS_ERRORTEXT_psArray_ARRAY_NULL;
*PS_ERRORTEXT_psArray_POSITION_BEYOND_NALLOC = *pslibc::PS_ERRORTEXT_psArray_POSITION_BEYOND_NALLOC;
*PS_ERRORTEXT_psVector_REALLOC_NULL = *pslibc::PS_ERRORTEXT_psVector_REALLOC_NULL;
*PS_ERRORTEXT_psVector_NOT_A_VECTOR = *pslibc::PS_ERRORTEXT_psVector_NOT_A_VECTOR;
*PS_ERRORTEXT_psVector_SORT_NULL = *pslibc::PS_ERRORTEXT_psVector_SORT_NULL;
*PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE = *pslibc::PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE;
*PS_ERRORTEXT_psBitSet_ALLOC_NEG_SIZE = *pslibc::PS_ERRORTEXT_psBitSet_ALLOC_NEG_SIZE;
*PS_ERRORTEXT_psBitSet_SET_NULL = *pslibc::PS_ERRORTEXT_psBitSet_SET_NULL;
*PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE = *pslibc::PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE;
*PS_ERRORTEXT_psBitSet_OPERATOR_NULL = *pslibc::PS_ERRORTEXT_psBitSet_OPERATOR_NULL;
*PS_ERRORTEXT_psBitSet_OPERATOR_INVALID = *pslibc::PS_ERRORTEXT_psBitSet_OPERATOR_INVALID;
*PS_ERRORTEXT_psBitSet_FIRST_OPERAND_NULL = *pslibc::PS_ERRORTEXT_psBitSet_FIRST_OPERAND_NULL;
*PS_ERRORTEXT_psBitSet_SECOND_OPERAND_NULL = *pslibc::PS_ERRORTEXT_psBitSet_SECOND_OPERAND_NULL;
*PS_ERRORTEXT_psBitSet_OPERANDS_SIZE_DIFFER = *pslibc::PS_ERRORTEXT_psBitSet_OPERANDS_SIZE_DIFFER;
*PS_ERRORTEXT_psBitSet_NOT_OP_FAILED = *pslibc::PS_ERRORTEXT_psBitSet_NOT_OP_FAILED;
*PS_ERRORTEXT_psBitSet_OPERAND_NULL = *pslibc::PS_ERRORTEXT_psBitSet_OPERAND_NULL;
*PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE = *pslibc::PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE;
*PS_ERRORTEXT_psScalar_COPY_NULL = *pslibc::PS_ERRORTEXT_psScalar_COPY_NULL;
*PS_ERRORTEXT_psHash_KEY_NULL = *pslibc::PS_ERRORTEXT_psHash_KEY_NULL;
*PS_ERRORTEXT_psHash_TABLE_NULL = *pslibc::PS_ERRORTEXT_psHash_TABLE_NULL;
*PS_ERRORTEXT_psHash_DATA_NULL = *pslibc::PS_ERRORTEXT_psHash_DATA_NULL;
*PS_ERRORTEXT_psList_LOCATION_INVALID = *pslibc::PS_ERRORTEXT_psList_LOCATION_INVALID;
*PS_ERRORTEXT_psList_ITERATOR_INVALID = *pslibc::PS_ERRORTEXT_psList_ITERATOR_INVALID;
*PS_ERRORTEXT_psList_ITERATOR_NULL = *pslibc::PS_ERRORTEXT_psList_ITERATOR_NULL;
*PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE = *pslibc::PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE;
*PS_ERRORTEXT_psList_LIST_NULL = *pslibc::PS_ERRORTEXT_psList_LIST_NULL;
*PS_ERRORTEXT_psList_DATA_NULL = *pslibc::PS_ERRORTEXT_psList_DATA_NULL;
*PS_ERRORTEXT_psList_DATA_NOT_FOUND = *pslibc::PS_ERRORTEXT_psList_DATA_NOT_FOUND;
*PS_LIST_HEAD = *pslibc::PS_LIST_HEAD;
*PS_LIST_TAIL = *pslibc::PS_LIST_TAIL;
*PS_ERRORTEXT_psTime_FILE_NOT_FOUND = *pslibc::PS_ERRORTEXT_psTime_FILE_NOT_FOUND;
*PS_ERRORTEXT_psTime_FILE_TOO_MANY_ROWS = *pslibc::PS_ERRORTEXT_psTime_FILE_TOO_MANY_ROWS;
*PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLE = *pslibc::PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLE;
*PS_ERRORTEXT_psTime_TIME_PREDATES_TABLE = *pslibc::PS_ERRORTEXT_psTime_TIME_PREDATES_TABLE;
*PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES = *pslibc::PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES;
*PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES = *pslibc::PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES;
*PS_ERRORTEXT_psTime_TABLE_DUPLICATE_ROWS = *pslibc::PS_ERRORTEXT_psTime_TABLE_DUPLICATE_ROWS;
*PS_ERRORTEXT_psTime_TYPE_UNKNOWN = *pslibc::PS_ERRORTEXT_psTime_TYPE_UNKNOWN;
*PS_ERRORTEXT_psTime_TYPE_INCORRECT = *pslibc::PS_ERRORTEXT_psTime_TYPE_INCORRECT;
*PS_ERRORTEXT_psTime_TYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psTime_TYPE_MISMATCH;
*PS_ERRORTEXT_psTime_GET_TOD_FAILED = *pslibc::PS_ERRORTEXT_psTime_GET_TOD_FAILED;
*PS_ERRORTEXT_psTime_CONVERT_TIME_TO_STRING_FAILED = *pslibc::PS_ERRORTEXT_psTime_CONVERT_TIME_TO_STRING_FAILED;
*PS_ERRORTEXT_psTime_APPEND_MSEC_FAILED = *pslibc::PS_ERRORTEXT_psTime_APPEND_MSEC_FAILED;
*PS_ERRORTEXT_psTime_USEC_INVALID = *pslibc::PS_ERRORTEXT_psTime_USEC_INVALID;
*PS_ERRORTEXT_psTime_ISOTIME_MALFORMED = *pslibc::PS_ERRORTEXT_psTime_ISOTIME_MALFORMED;
*PS_ERRORTEXT_psTime_INTERPOLATION_FAILED = *pslibc::PS_ERRORTEXT_psTime_INTERPOLATION_FAILED;
*PS_ERRORTEXT_psTime_INTERPOLATION_FAILED_NAME = *pslibc::PS_ERRORTEXT_psTime_INTERPOLATION_FAILED_NAME;
*PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED = *pslibc::PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED;
*PS_ERRORTEXT_psTime_BAD_TABLE_COUNT = *pslibc::PS_ERRORTEXT_psTime_BAD_TABLE_COUNT;
*PS_ERRORTEXT_psTime_BAD_VECTOR = *pslibc::PS_ERRORTEXT_psTime_BAD_VECTOR;
*PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNDEFINED = *pslibc::PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNDEFINED;
*PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN = *pslibc::PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN;
*PS_ERRORTEXT_psCoord_UNITS_UNKNOWN = *pslibc::PS_ERRORTEXT_psCoord_UNITS_UNKNOWN;
*PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN = *pslibc::PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN;
*PS_ERRORTEXT_psCoord_INVALID_MJD = *pslibc::PS_ERRORTEXT_psCoord_INVALID_MJD;
*PS_ERRORTEXT_psAstrometry_NONLINEAR_TRANSFORM = *pslibc::PS_ERRORTEXT_psAstrometry_NONLINEAR_TRANSFORM;
*PS_ERRORTEXT_psMetadata_METATYPE_INVALID = *pslibc::PS_ERRORTEXT_psMetadata_METATYPE_INVALID;
*PS_ERRORTEXT_psMetadata_FORMAT_INVALID = *pslibc::PS_ERRORTEXT_psMetadata_FORMAT_INVALID;
*PS_ERRORTEXT_psMetadata_METATYPE_MISMATCH = *pslibc::PS_ERRORTEXT_psMetadata_METATYPE_MISMATCH;
*PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED;
*PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED;
*PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED;
*PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED;
*PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED;
*PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED;
*PS_ERRORTEXT_psMetadata_ADD_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_ADD_FAILED;
*PS_ERRORTEXT_psMetadata_FIND_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_FIND_FAILED;
*PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED = *pslibc::PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED;
*PS_ERRORTEXT_psMetadata_DUPLICATE_NOT_ALLOWED = *pslibc::PS_ERRORTEXT_psMetadata_DUPLICATE_NOT_ALLOWED;
*PS_ERRORTEXT_psMetadata_REGEX_INVALID = *pslibc::PS_ERRORTEXT_psMetadata_REGEX_INVALID;
*PS_ERRORTEXT_psMetadata_LOCATION_INVALID = *pslibc::PS_ERRORTEXT_psMetadata_LOCATION_INVALID;
*PS_ERRORTEXT_psMetadataIO_TYPE_INVALID = *pslibc::PS_ERRORTEXT_psMetadataIO_TYPE_INVALID;
*PS_ERRORTEXT_psMetadataIO_EXTNUM_NOTPOSITIVE = *pslibc::PS_ERRORTEXT_psMetadataIO_EXTNUM_NOTPOSITIVE;
*PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID = *pslibc::PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID;
*PS_ERRORTEXT_psMetadataIO_ADD_FAILED = *pslibc::PS_ERRORTEXT_psMetadataIO_ADD_FAILED;
*PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED = *pslibc::PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED;
*PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR = *pslibc::PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR;
*PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL = *pslibc::PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL;
*PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID = *pslibc::PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID;
*PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM = *pslibc::PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM;
*PS_ERRORTEXT_psMetadataIO_PARSE_FAILED = *pslibc::PS_ERRORTEXT_psMetadataIO_PARSE_FAILED;
*PS_ERRORTEXT_psMetadataIO_NO_NAME = *pslibc::PS_ERRORTEXT_psMetadataIO_NO_NAME;
*PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE = *pslibc::PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE;
*PS_ERRORTEXT_psMetadataIO_TAG_MISMATCH = *pslibc::PS_ERRORTEXT_psMetadataIO_TAG_MISMATCH;
*PS_ERRORTEXT_psMetadataIO_TAG_UNKNOWN = *pslibc::PS_ERRORTEXT_psMetadataIO_TAG_UNKNOWN;
*PS_PROJ_TAN = *pslibc::PS_PROJ_TAN;
*PS_PROJ_SIN = *pslibc::PS_PROJ_SIN;
*PS_PROJ_AIT = *pslibc::PS_PROJ_AIT;
*PS_PROJ_PAR = *pslibc::PS_PROJ_PAR;
*PS_PROJ_NTYPE = *pslibc::PS_PROJ_NTYPE;
*PS_SPHERICAL = *pslibc::PS_SPHERICAL;
*PS_LINEAR = *pslibc::PS_LINEAR;
*PS_ARCSEC = *pslibc::PS_ARCSEC;
*PS_ARCMIN = *pslibc::PS_ARCMIN;
*PS_DEGREE = *pslibc::PS_DEGREE;
*PS_RADIAN = *pslibc::PS_RADIAN;
*PS_META_S32 = *pslibc::PS_META_S32;
*PS_META_F32 = *pslibc::PS_META_F32;
*PS_META_F64 = *pslibc::PS_META_F64;
*PS_META_BOOL = *pslibc::PS_META_BOOL;
*PS_META_LIST = *pslibc::PS_META_LIST;
*PS_META_STR = *pslibc::PS_META_STR;
*PS_META_VEC = *pslibc::PS_META_VEC;
*PS_META_IMG = *pslibc::PS_META_IMG;
*PS_META_HASH = *pslibc::PS_META_HASH;
*PS_META_LOOKUPTABLE = *pslibc::PS_META_LOOKUPTABLE;
*PS_META_JPEG = *pslibc::PS_META_JPEG;
*PS_META_PNG = *pslibc::PS_META_PNG;
*PS_META_ASTROM = *pslibc::PS_META_ASTROM;
*PS_META_UNKNOWN = *pslibc::PS_META_UNKNOWN;
*PS_META_MULTI = *pslibc::PS_META_MULTI;
*PS_META_DEFAULT = *pslibc::PS_META_DEFAULT;
*PS_META_REPLACE = *pslibc::PS_META_REPLACE;
*PS_META_DUPLICATE_OK = *pslibc::PS_META_DUPLICATE_OK;
*PS_METADATA_FLAGS_MASK = *pslibc::PS_METADATA_FLAGS_MASK;
*PS_METADATA_TYPE_MASK = *pslibc::PS_METADATA_TYPE_MASK;
*PS_TIME_TAI = *pslibc::PS_TIME_TAI;
*PS_TIME_UTC = *pslibc::PS_TIME_UTC;
1;
