/*
This file is part of Darling.

Copyright (C) 2017 Lubos Dolezel
    
Darling is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Darling is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with Darling.  If not, see <http://www.gnu.org/licenses/>.
*/


#include <stdlib.h>
#include <stdio.h>

static int verbose = 0;
__attribute__((constructor)) static void initme(void) {
    verbose = getenv("STUB_VERBOSE") != NULL;
}
void* DIADCCompressorCalculateBufferSize(void) { if (verbose) puts("STUB: DIADCCompressorCalculateBufferSize called"); return NULL; }
void* DIADCCompressorCompressData(void) { if (verbose) puts("STUB: DIADCCompressorCompressData called"); return NULL; }
void* DIADCCompressorDelete(void) { if (verbose) puts("STUB: DIADCCompressorDelete called"); return NULL; }
void* DIADCCompressorNew(void) { if (verbose) puts("STUB: DIADCCompressorNew called"); return NULL; }
void* DIAddPermission(void) { if (verbose) puts("STUB: DIAddPermission called"); return NULL; }
void* DIAddRunToBLKX(void) { if (verbose) puts("STUB: DIAddRunToBLKX called"); return NULL; }
void* DIAttachDrive(void) { if (verbose) puts("STUB: DIAttachDrive called"); return NULL; }
void* DIAttachImage(void) { if (verbose) puts("STUB: DIAttachImage called"); return NULL; }
void* DIAuthOpen(void) { if (verbose) puts("STUB: DIAuthOpen called"); return NULL; }
void* DIBackingStoreAddRsrcFork(void) { if (verbose) puts("STUB: DIBackingStoreAddRsrcFork called"); return NULL; }
void* DIBackingStoreAllowExpandability(void) { if (verbose) puts("STUB: DIBackingStoreAllowExpandability called"); return NULL; }
void* DIBackingStoreCanEnumerateDirectory(void) { if (verbose) puts("STUB: DIBackingStoreCanEnumerateDirectory called"); return NULL; }
void* DIBackingStoreChangeKey(void) { if (verbose) puts("STUB: DIBackingStoreChangeKey called"); return NULL; }
void* DIBackingStoreCloseDataFork(void) { if (verbose) puts("STUB: DIBackingStoreCloseDataFork called"); return NULL; }
void* DIBackingStoreCloseResourceFile(void) { if (verbose) puts("STUB: DIBackingStoreCloseResourceFile called"); return NULL; }
void* DIBackingStoreCloseRsrcFork(void) { if (verbose) puts("STUB: DIBackingStoreCloseRsrcFork called"); return NULL; }
void* DIBackingStoreCopyAttr(void) { if (verbose) puts("STUB: DIBackingStoreCopyAttr called"); return NULL; }
void* DIBackingStoreCopyEncryptedInformation(void) { if (verbose) puts("STUB: DIBackingStoreCopyEncryptedInformation called"); return NULL; }
void* DIBackingStoreDelete(void) { if (verbose) puts("STUB: DIBackingStoreDelete called"); return NULL; }
void* DIBackingStoreEnumerateDirectory(void) { if (verbose) puts("STUB: DIBackingStoreEnumerateDirectory called"); return NULL; }
void* DIBackingStoreFlush(void) { if (verbose) puts("STUB: DIBackingStoreFlush called"); return NULL; }
void* DIBackingStoreFlushWithFlags(void) { if (verbose) puts("STUB: DIBackingStoreFlushWithFlags called"); return NULL; }
void* DIBackingStoreGetBaseBackingStore(void) { if (verbose) puts("STUB: DIBackingStoreGetBaseBackingStore called"); return NULL; }
void* DIBackingStoreGetDataForkLength(void) { if (verbose) puts("STUB: DIBackingStoreGetDataForkLength called"); return NULL; }
void* DIBackingStoreGetExpandability(void) { if (verbose) puts("STUB: DIBackingStoreGetExpandability called"); return NULL; }
void* DIBackingStoreGetExtension(void) { if (verbose) puts("STUB: DIBackingStoreGetExtension called"); return NULL; }
void* DIBackingStoreGetFileCreator(void) { if (verbose) puts("STUB: DIBackingStoreGetFileCreator called"); return NULL; }
void* DIBackingStoreGetFileType(void) { if (verbose) puts("STUB: DIBackingStoreGetFileType called"); return NULL; }
void* DIBackingStoreGetMaxDataForkLength(void) { if (verbose) puts("STUB: DIBackingStoreGetMaxDataForkLength called"); return NULL; }
void* DIBackingStoreGetMaxRsrcForkLength(void) { if (verbose) puts("STUB: DIBackingStoreGetMaxRsrcForkLength called"); return NULL; }
void* DIBackingStoreGetName(void) { if (verbose) puts("STUB: DIBackingStoreGetName called"); return NULL; }
void* DIBackingStoreGetPath(void) { if (verbose) puts("STUB: DIBackingStoreGetPath called"); return NULL; }
void* DIBackingStoreGetRsrcForkLength(void) { if (verbose) puts("STUB: DIBackingStoreGetRsrcForkLength called"); return NULL; }
void* DIBackingStoreGetURL(void) { if (verbose) puts("STUB: DIBackingStoreGetURL called"); return NULL; }
void* DIBackingStoreGetURLArray(void) { if (verbose) puts("STUB: DIBackingStoreGetURLArray called"); return NULL; }
void* DIBackingStoreGetUniqueIdentifier(void) { if (verbose) puts("STUB: DIBackingStoreGetUniqueIdentifier called"); return NULL; }
void* DIBackingStoreHandleIdle(void) { if (verbose) puts("STUB: DIBackingStoreHandleIdle called"); return NULL; }
void* DIBackingStoreHandlePowerChange(void) { if (verbose) puts("STUB: DIBackingStoreHandlePowerChange called"); return NULL; }
void* DIBackingStoreHasEncryptedEncoding(void) { if (verbose) puts("STUB: DIBackingStoreHasEncryptedEncoding called"); return NULL; }
void* DIBackingStoreHasFileCreator(void) { if (verbose) puts("STUB: DIBackingStoreHasFileCreator called"); return NULL; }
void* DIBackingStoreHasFileType(void) { if (verbose) puts("STUB: DIBackingStoreHasFileType called"); return NULL; }
void* DIBackingStoreIsEncrypted(void) { if (verbose) puts("STUB: DIBackingStoreIsEncrypted called"); return NULL; }
void* DIBackingStoreIsRemote(void) { if (verbose) puts("STUB: DIBackingStoreIsRemote called"); return NULL; }
void* DIBackingStoreIsWriteEnabled(void) { if (verbose) puts("STUB: DIBackingStoreIsWriteEnabled called"); return NULL; }
void* DIBackingStoreNewWithCFURL(void) { if (verbose) puts("STUB: DIBackingStoreNewWithCFURL called"); return NULL; }
void* DIBackingStoreOnLockedMedia(void) { if (verbose) puts("STUB: DIBackingStoreOnLockedMedia called"); return NULL; }
void* DIBackingStoreOpenDataFork(void) { if (verbose) puts("STUB: DIBackingStoreOpenDataFork called"); return NULL; }
void* DIBackingStoreOpenResourceFile(void) { if (verbose) puts("STUB: DIBackingStoreOpenResourceFile called"); return NULL; }
void* DIBackingStoreOpenRsrcFork(void) { if (verbose) puts("STUB: DIBackingStoreOpenRsrcFork called"); return NULL; }
void* DIBackingStoreReadDataFork(void) { if (verbose) puts("STUB: DIBackingStoreReadDataFork called"); return NULL; }
void* DIBackingStoreReadRsrcFork(void) { if (verbose) puts("STUB: DIBackingStoreReadRsrcFork called"); return NULL; }
void* DIBackingStoreSetAttr(void) { if (verbose) puts("STUB: DIBackingStoreSetAttr called"); return NULL; }
void* DIBackingStoreSetDataForkLength(void) { if (verbose) puts("STUB: DIBackingStoreSetDataForkLength called"); return NULL; }
void* DIBackingStoreSetExpandability(void) { if (verbose) puts("STUB: DIBackingStoreSetExpandability called"); return NULL; }
void* DIBackingStoreSetFileCreator(void) { if (verbose) puts("STUB: DIBackingStoreSetFileCreator called"); return NULL; }
void* DIBackingStoreSetFileType(void) { if (verbose) puts("STUB: DIBackingStoreSetFileType called"); return NULL; }
void* DIBackingStoreSetPermission(void) { if (verbose) puts("STUB: DIBackingStoreSetPermission called"); return NULL; }
void* DIBackingStoreSetRsrcForkLength(void) { if (verbose) puts("STUB: DIBackingStoreSetRsrcForkLength called"); return NULL; }
void* DIBackingStoreUnlink(void) { if (verbose) puts("STUB: DIBackingStoreUnlink called"); return NULL; }
void* DIBackingStoreWriteDataFork(void) { if (verbose) puts("STUB: DIBackingStoreWriteDataFork called"); return NULL; }
void* DIBackingStoreWriteRsrcFork(void) { if (verbose) puts("STUB: DIBackingStoreWriteRsrcFork called"); return NULL; }
void* DIChecksumDelete(void) { if (verbose) puts("STUB: DIChecksumDelete called"); return NULL; }
void* DIChecksumGetBitCount(void) { if (verbose) puts("STUB: DIChecksumGetBitCount called"); return NULL; }
void* DIChecksumGetChecksumStruct(void) { if (verbose) puts("STUB: DIChecksumGetChecksumStruct called"); return NULL; }
void* DIChecksumGetChecksumType(void) { if (verbose) puts("STUB: DIChecksumGetChecksumType called"); return NULL; }
void* DIChecksumGetLongName(void) { if (verbose) puts("STUB: DIChecksumGetLongName called"); return NULL; }
void* DIChecksumGetShortName(void) { if (verbose) puts("STUB: DIChecksumGetShortName called"); return NULL; }
void* DIChecksumGetValue(void) { if (verbose) puts("STUB: DIChecksumGetValue called"); return NULL; }
void* DIChecksumGetValueString(void) { if (verbose) puts("STUB: DIChecksumGetValueString called"); return NULL; }
void* DIChecksumHDIChecksumAreEqual(void) { if (verbose) puts("STUB: DIChecksumHDIChecksumAreEqual called"); return NULL; }
void* DIChecksumIsEmpty(void) { if (verbose) puts("STUB: DIChecksumIsEmpty called"); return NULL; }
void* DIChecksumIsEqual(void) { if (verbose) puts("STUB: DIChecksumIsEqual called"); return NULL; }
void* DIChecksumNewOfSameKindAs(void) { if (verbose) puts("STUB: DIChecksumNewOfSameKindAs called"); return NULL; }
void* DIChecksumNewUsingChecksumStruct(void) { if (verbose) puts("STUB: DIChecksumNewUsingChecksumStruct called"); return NULL; }
void* DIChecksumNewWith(void) { if (verbose) puts("STUB: DIChecksumNewWith called"); return NULL; }
void* DIChecksumProcessBuffer(void) { if (verbose) puts("STUB: DIChecksumProcessBuffer called"); return NULL; }
void* DIChecksumProcessConstant(void) { if (verbose) puts("STUB: DIChecksumProcessConstant called"); return NULL; }
void* DIChecksumProcessFinish(void) { if (verbose) puts("STUB: DIChecksumProcessFinish called"); return NULL; }
void* DIChecksumProcessStart(void) { if (verbose) puts("STUB: DIChecksumProcessStart called"); return NULL; }
void* DIChecksumSetValue(void) { if (verbose) puts("STUB: DIChecksumSetValue called"); return NULL; }
void* DICopyDevEntries(void) { if (verbose) puts("STUB: DICopyDevEntries called"); return NULL; }
void* DICopyDiskImageMountPointDictionary(void) { if (verbose) puts("STUB: DICopyDiskImageMountPointDictionary called"); return NULL; }
void* DICopyIdentifiableFileSystemsInfo(void) { if (verbose) puts("STUB: DICopyIdentifiableFileSystemsInfo called"); return NULL; }
void* DICopyStrError(void) { if (verbose) puts("STUB: DICopyStrError called"); return NULL; }
void* DICopyStrError_real(void) { if (verbose) puts("STUB: DICopyStrError_real called"); return NULL; }
void* DICopyWriteableFileSystemsArray(void) { if (verbose) puts("STUB: DICopyWriteableFileSystemsArray called"); return NULL; }
void* DICreateBackingStore(void) { if (verbose) puts("STUB: DICreateBackingStore called"); return NULL; }
void* DICreateDiskImage(void) { if (verbose) puts("STUB: DICreateDiskImage called"); return NULL; }
void* DICreateNewUDIFSegmentURL(void) { if (verbose) puts("STUB: DICreateNewUDIFSegmentURL called"); return NULL; }
void* DICreatePermissionDictionary(void) { if (verbose) puts("STUB: DICreatePermissionDictionary called"); return NULL; }
void* DIDARTDiskImageGetDartFileHeader(void) { if (verbose) puts("STUB: DIDARTDiskImageGetDartFileHeader called"); return NULL; }
void* DIDeinitialize(void) { if (verbose) puts("STUB: DIDeinitialize called"); return NULL; }
void* DIDevEntryCopyDeviceInfo(void) { if (verbose) puts("STUB: DIDevEntryCopyDeviceInfo called"); return NULL; }
void* DIDevEntryGetInformation(void) { if (verbose) puts("STUB: DIDevEntryGetInformation called"); return NULL; }
void* DIDevEntryToIOKitObject(void) { if (verbose) puts("STUB: DIDevEntryToIOKitObject called"); return NULL; }
void* DIDevEntryToRawDevice(void) { if (verbose) puts("STUB: DIDevEntryToRawDevice called"); return NULL; }
void* DIDiskCopy42DiskImageGetDiskCopy42Header(void) { if (verbose) puts("STUB: DIDiskCopy42DiskImageGetDiskCopy42Header called"); return NULL; }
void* DIDiskImageAttach(void) { if (verbose) puts("STUB: DIDiskImageAttach called"); return NULL; }
void* DIDiskImageBurn(void) { if (verbose) puts("STUB: DIDiskImageBurn called"); return NULL; }
void* DIDiskImageCalcChecksum(void) { if (verbose) puts("STUB: DIDiskImageCalcChecksum called"); return NULL; }
void* DIDiskImageCallProgressCancelProc(void) { if (verbose) puts("STUB: DIDiskImageCallProgressCancelProc called"); return NULL; }
void* DIDiskImageCallProgressMessageProc(void) { if (verbose) puts("STUB: DIDiskImageCallProgressMessageProc called"); return NULL; }
void* DIDiskImageCallProgressPercentProc(void) { if (verbose) puts("STUB: DIDiskImageCallProgressPercentProc called"); return NULL; }
void* DIDiskImageCanBeAppended(void) { if (verbose) puts("STUB: DIDiskImageCanBeAppended called"); return NULL; }
void* DIDiskImageCanBeBurned(void) { if (verbose) puts("STUB: DIDiskImageCanBeBurned called"); return NULL; }
void* DIDiskImageCancelNow(void) { if (verbose) puts("STUB: DIDiskImageCancelNow called"); return NULL; }
void* DIDiskImageChangeKey(void) { if (verbose) puts("STUB: DIDiskImageChangeKey called"); return NULL; }
void* DIDiskImageCompact(void) { if (verbose) puts("STUB: DIDiskImageCompact called"); return NULL; }
void* DIDiskImageContentResize(void) { if (verbose) puts("STUB: DIDiskImageContentResize called"); return NULL; }
void* DIDiskImageConvertWithDiskImage(void) { if (verbose) puts("STUB: DIDiskImageConvertWithDiskImage called"); return NULL; }
void* DIDiskImageCopyChecksumReportString(void) { if (verbose) puts("STUB: DIDiskImageCopyChecksumReportString called"); return NULL; }
void* DIDiskImageCopyFormatDescriptionString(void) { if (verbose) puts("STUB: DIDiskImageCopyFormatDescriptionString called"); return NULL; }
void* DIDiskImageCopyIconURL(void) { if (verbose) puts("STUB: DIDiskImageCopyIconURL called"); return NULL; }
void* DIDiskImageCopyImageChecksum(void) { if (verbose) puts("STUB: DIDiskImageCopyImageChecksum called"); return NULL; }
void* DIDiskImageCopyImageInformation(void) { if (verbose) puts("STUB: DIDiskImageCopyImageInformation called"); return NULL; }
void* DIDiskImageCopyKernelAttachDictionary(void) { if (verbose) puts("STUB: DIDiskImageCopyKernelAttachDictionary called"); return NULL; }
void* DIDiskImageCopyMountPointDictionary(void) { if (verbose) puts("STUB: DIDiskImageCopyMountPointDictionary called"); return NULL; }
void* DIDiskImageCopyNonKernelAttachDictionary(void) { if (verbose) puts("STUB: DIDiskImageCopyNonKernelAttachDictionary called"); return NULL; }
void* DIDiskImageCopyResizeInformation(void) { if (verbose) puts("STUB: DIDiskImageCopyResizeInformation called"); return NULL; }
void* DIDiskImageCopySLADictionary(void) { if (verbose) puts("STUB: DIDiskImageCopySLADictionary called"); return NULL; }
void* DIDiskImageCreateChecksum(void) { if (verbose) puts("STUB: DIDiskImageCreateChecksum called"); return NULL; }
void* DIDiskImageCreateDRTrackForImage(void) { if (verbose) puts("STUB: DIDiskImageCreateDRTrackForImage called"); return NULL; }
void* DIDiskImageDelete(void) { if (verbose) puts("STUB: DIDiskImageDelete called"); return NULL; }
void* DIDiskImageEstimateSectorsNeededForBurn(void) { if (verbose) puts("STUB: DIDiskImageEstimateSectorsNeededForBurn called"); return NULL; }
void* DIDiskImageFlush(void) { if (verbose) puts("STUB: DIDiskImageFlush called"); return NULL; }
void* DIDiskImageGetBackingStore(void) { if (verbose) puts("STUB: DIDiskImageGetBackingStore called"); return NULL; }
void* DIDiskImageGetImageFormat(void) { if (verbose) puts("STUB: DIDiskImageGetImageFormat called"); return NULL; }
void* DIDiskImageGetSectorCount(void) { if (verbose) puts("STUB: DIDiskImageGetSectorCount called"); return NULL; }
void* DIDiskImageGetUniqueIDDict(void) { if (verbose) puts("STUB: DIDiskImageGetUniqueIDDict called"); return NULL; }
void* DIDiskImageGetVirtualBandSize(void) { if (verbose) puts("STUB: DIDiskImageGetVirtualBandSize called"); return NULL; }
void* DIDiskImageHandleIdle(void) { if (verbose) puts("STUB: DIDiskImageHandleIdle called"); return NULL; }
void* DIDiskImageHandlePowerChange(void) { if (verbose) puts("STUB: DIDiskImageHandlePowerChange called"); return NULL; }
void* DIDiskImageHasChecksum(void) { if (verbose) puts("STUB: DIDiskImageHasChecksum called"); return NULL; }
void* DIDiskImageHasPartitionMap(void) { if (verbose) puts("STUB: DIDiskImageHasPartitionMap called"); return NULL; }
void* DIDiskImageHasValidChecksum(void) { if (verbose) puts("STUB: DIDiskImageHasValidChecksum called"); return NULL; }
void* DIDiskImageInUse(void) { if (verbose) puts("STUB: DIDiskImageInUse called"); return NULL; }
void* DIDiskImageIsEncrypted(void) { if (verbose) puts("STUB: DIDiskImageIsEncrypted called"); return NULL; }
void* DIDiskImageIsHFS(void) { if (verbose) puts("STUB: DIDiskImageIsHFS called"); return NULL; }
void* DIDiskImageIsHFSPlus(void) { if (verbose) puts("STUB: DIDiskImageIsHFSPlus called"); return NULL; }
void* DIDiskImageIsHFSPlusWithWrapper(void) { if (verbose) puts("STUB: DIDiskImageIsHFSPlusWithWrapper called"); return NULL; }
void* DIDiskImageIsHFSX(void) { if (verbose) puts("STUB: DIDiskImageIsHFSX called"); return NULL; }
void* DIDiskImageIsISO9660(void) { if (verbose) puts("STUB: DIDiskImageIsISO9660 called"); return NULL; }
void* DIDiskImageIsKernelCompatible(void) { if (verbose) puts("STUB: DIDiskImageIsKernelCompatible called"); return NULL; }
void* DIDiskImageIsMFS(void) { if (verbose) puts("STUB: DIDiskImageIsMFS called"); return NULL; }
void* DIDiskImageIsProDOS(void) { if (verbose) puts("STUB: DIDiskImageIsProDOS called"); return NULL; }
void* DIDiskImageIsUDF(void) { if (verbose) puts("STUB: DIDiskImageIsUDF called"); return NULL; }
void* DIDiskImageIsUFS(void) { if (verbose) puts("STUB: DIDiskImageIsUFS called"); return NULL; }
void* DIDiskImageIsWriteEnabled(void) { if (verbose) puts("STUB: DIDiskImageIsWriteEnabled called"); return NULL; }
void* DIDiskImageObjectCallDIProgressCallBackProc(void) { if (verbose) puts("STUB: DIDiskImageObjectCallDIProgressCallBackProc called"); return NULL; }
void* DIDiskImageObjectGetClassName(void) { if (verbose) puts("STUB: DIDiskImageObjectGetClassName called"); return NULL; }
void* DIDiskImageObjectGetDIProgressCallBackProcPtr(void) { if (verbose) puts("STUB: DIDiskImageObjectGetDIProgressCallBackProcPtr called"); return NULL; }
void* DIDiskImageObjectGetProperty(void) { if (verbose) puts("STUB: DIDiskImageObjectGetProperty called"); return NULL; }
void* DIDiskImageObjectGetRefCon(void) { if (verbose) puts("STUB: DIDiskImageObjectGetRefCon called"); return NULL; }
void* DIDiskImageObjectRelease(void) { if (verbose) puts("STUB: DIDiskImageObjectRelease called"); return NULL; }
void* DIDiskImageObjectRetain(void) { if (verbose) puts("STUB: DIDiskImageObjectRetain called"); return NULL; }
void* DIDiskImageObjectSetDIProgressCallBackProcPtr(void) { if (verbose) puts("STUB: DIDiskImageObjectSetDIProgressCallBackProcPtr called"); return NULL; }
void* DIDiskImageObjectSetProperty(void) { if (verbose) puts("STUB: DIDiskImageObjectSetProperty called"); return NULL; }
void* DIDiskImageObjectSetRefCon(void) { if (verbose) puts("STUB: DIDiskImageObjectSetRefCon called"); return NULL; }
void* DIDiskImageReadSectors(void) { if (verbose) puts("STUB: DIDiskImageReadSectors called"); return NULL; }
void* DIDiskImageSetProgressCancelProcPtr(void) { if (verbose) puts("STUB: DIDiskImageSetProgressCancelProcPtr called"); return NULL; }
void* DIDiskImageSetProgressMessageProcPtr(void) { if (verbose) puts("STUB: DIDiskImageSetProgressMessageProcPtr called"); return NULL; }
void* DIDiskImageSetProgressPercentProcPtr(void) { if (verbose) puts("STUB: DIDiskImageSetProgressPercentProcPtr called"); return NULL; }
void* DIDiskImageSetSectorCount(void) { if (verbose) puts("STUB: DIDiskImageSetSectorCount called"); return NULL; }
void* DIDiskImageValidateChecksum(void) { if (verbose) puts("STUB: DIDiskImageValidateChecksum called"); return NULL; }
void* DIDiskImageValidateChecksumWithFlags(void) { if (verbose) puts("STUB: DIDiskImageValidateChecksumWithFlags called"); return NULL; }
void* DIDiskImageWriteSectors(void) { if (verbose) puts("STUB: DIDiskImageWriteSectors called"); return NULL; }
void* DIEnableSecureMode(void) { if (verbose) puts("STUB: DIEnableSecureMode called"); return NULL; }
void* DIEnumerateCarbonVolNames(void) { if (verbose) puts("STUB: DIEnumerateCarbonVolNames called"); return NULL; }
void* DIEnumerateMountPoints(void) { if (verbose) puts("STUB: DIEnumerateMountPoints called"); return NULL; }
void* DIEnumerateVRefNums(void) { if (verbose) puts("STUB: DIEnumerateVRefNums called"); return NULL; }
void* DIEnumerateWholeDiskDevEntries(void) { if (verbose) puts("STUB: DIEnumerateWholeDiskDevEntries called"); return NULL; }
void* DIGetBackingStorePluginCount(void) { if (verbose) puts("STUB: DIGetBackingStorePluginCount called"); return NULL; }
void* DIGetBundleRef(void) { if (verbose) puts("STUB: DIGetBundleRef called"); return NULL; }
void* DIGetDebugLevel(void) { if (verbose) puts("STUB: DIGetDebugLevel called"); return NULL; }
void* DIGetDevEntryInTree(void) { if (verbose) puts("STUB: DIGetDevEntryInTree called"); return NULL; }
void* DIGetDiskImagePluginCount(void) { if (verbose) puts("STUB: DIGetDiskImagePluginCount called"); return NULL; }
void* DIGetDriverVersion(void) { if (verbose) puts("STUB: DIGetDriverVersion called"); return NULL; }
void* DIGetFileEncodingPluginCount(void) { if (verbose) puts("STUB: DIGetFileEncodingPluginCount called"); return NULL; }
void* DIGetFrameworkVersion(void) { if (verbose) puts("STUB: DIGetFrameworkVersion called"); return NULL; }
void* DIGetLocalKey(void) { if (verbose) puts("STUB: DIGetLocalKey called"); return NULL; }
void* DIGetPermission(void) { if (verbose) puts("STUB: DIGetPermission called"); return NULL; }
void* DIGetPluginPropertyDicts(void) { if (verbose) puts("STUB: DIGetPluginPropertyDicts called"); return NULL; }
void* DIGetVerboseLevel(void) { if (verbose) puts("STUB: DIGetVerboseLevel called"); return NULL; }
void* DIHLCopyEncryptedStatus(void) { if (verbose) puts("STUB: DIHLCopyEncryptedStatus called"); return NULL; }
void* DIHLCopyImageForVolume(void) { if (verbose) puts("STUB: DIHLCopyImageForVolume called"); return NULL; }
void* DIHLCopyPreference(void) { if (verbose) puts("STUB: DIHLCopyPreference called"); return NULL; }
void* DIHLCopyPreferences(void) { if (verbose) puts("STUB: DIHLCopyPreferences called"); return NULL; }
void* DIHLCopyResizeInfo(void) { if (verbose) puts("STUB: DIHLCopyResizeInfo called"); return NULL; }
void* DIHLCopyStatusStageString(void) { if (verbose) puts("STUB: DIHLCopyStatusStageString called"); return NULL; }
void* DIHLCopyVolumeForImage(void) { if (verbose) puts("STUB: DIHLCopyVolumeForImage called"); return NULL; }
void* DIHLCopyVolumeRefNumDiskImageInfo(void) { if (verbose) puts("STUB: DIHLCopyVolumeRefNumDiskImageInfo called"); return NULL; }
void* DIHLDiskImageAttach(void) { if (verbose) puts("STUB: DIHLDiskImageAttach called"); return NULL; }
void* DIHLDiskImageChangePassword(void) { if (verbose) puts("STUB: DIHLDiskImageChangePassword called"); return NULL; }
void* DIHLDiskImageCompact(void) { if (verbose) puts("STUB: DIHLDiskImageCompact called"); return NULL; }
void* DIHLDiskImageCopyProperties(void) { if (verbose) puts("STUB: DIHLDiskImageCopyProperties called"); return NULL; }
void* DIHLDiskImageCreate(void) { if (verbose) puts("STUB: DIHLDiskImageCreate called"); return NULL; }
void* DIHLDiskImageProbeCatalogInfo(void) { if (verbose) puts("STUB: DIHLDiskImageProbeCatalogInfo called"); return NULL; }
void* DIHLDiskImageProbeURL(void) { if (verbose) puts("STUB: DIHLDiskImageProbeURL called"); return NULL; }
void* DIHLDiskImageSetProperty(void) { if (verbose) puts("STUB: DIHLDiskImageSetProperty called"); return NULL; }
void* DIHLEraseImageKeys(void) { if (verbose) puts("STUB: DIHLEraseImageKeys called"); return NULL; }
void* DIHLFVChangeMasterPassword(void) { if (verbose) puts("STUB: DIHLFVChangeMasterPassword called"); return NULL; }
void* DIHLFVChangePassword(void) { if (verbose) puts("STUB: DIHLFVChangePassword called"); return NULL; }
void* DIHLFVCompact(void) { if (verbose) puts("STUB: DIHLFVCompact called"); return NULL; }
void* DIHLFVCopyEncryptionIdentities(void) { if (verbose) puts("STUB: DIHLFVCopyEncryptionIdentities called"); return NULL; }
void* DIHLFVCreate(void) { if (verbose) puts("STUB: DIHLFVCreate called"); return NULL; }
void* DIHLFVMakeMasterPassword(void) { if (verbose) puts("STUB: DIHLFVMakeMasterPassword called"); return NULL; }
void* DIHLFVMasterPasswordEnabled(void) { if (verbose) puts("STUB: DIHLFVMasterPasswordEnabled called"); return NULL; }
void* DIHLFVMasterPasswordValidates(void) { if (verbose) puts("STUB: DIHLFVMasterPasswordValidates called"); return NULL; }
void* DIHLFVMount(void) { if (verbose) puts("STUB: DIHLFVMount called"); return NULL; }
void* DIHLFVResize(void) { if (verbose) puts("STUB: DIHLFVResize called"); return NULL; }
void* DIHLFVSetAltPassword(void) { if (verbose) puts("STUB: DIHLFVSetAltPassword called"); return NULL; }
void* DIHLFVUnmount(void) { if (verbose) puts("STUB: DIHLFVUnmount called"); return NULL; }
void* DIHLGetDefaultsDictionary(void) { if (verbose) puts("STUB: DIHLGetDefaultsDictionary called"); return NULL; }
void* DIHLResizeImage(void) { if (verbose) puts("STUB: DIHLResizeImage called"); return NULL; }
void* DIIOKitObjectCopyDeviceInfo(void) { if (verbose) puts("STUB: DIIOKitObjectCopyDeviceInfo called"); return NULL; }
void* DIIOKitObjectToDevEntry(void) { if (verbose) puts("STUB: DIIOKitObjectToDevEntry called"); return NULL; }
void* DIInitialize(void) { if (verbose) puts("STUB: DIInitialize called"); return NULL; }
void* DIIsInitialized(void) { if (verbose) puts("STUB: DIIsInitialized called"); return NULL; }
void* DIIsPotentiallyValidDiskImage(void) { if (verbose) puts("STUB: DIIsPotentiallyValidDiskImage called"); return NULL; }
void* DIKenCodeCompressorCalculateBufferSize(void) { if (verbose) puts("STUB: DIKenCodeCompressorCalculateBufferSize called"); return NULL; }
void* DIKenCodeCompressorCompressData(void) { if (verbose) puts("STUB: DIKenCodeCompressorCompressData called"); return NULL; }
void* DIKenCodeCompressorDelete(void) { if (verbose) puts("STUB: DIKenCodeCompressorDelete called"); return NULL; }
void* DIKenCodeCompressorNew(void) { if (verbose) puts("STUB: DIKenCodeCompressorNew called"); return NULL; }
void* DILoadDriver(void) { if (verbose) puts("STUB: DILoadDriver called"); return NULL; }
void* DIMakeStubBLKX(void) { if (verbose) puts("STUB: DIMakeStubBLKX called"); return NULL; }
void* DIMediaKitCreateMKMediaRef(void) { if (verbose) puts("STUB: DIMediaKitCreateMKMediaRef called"); return NULL; }
void* DIMediaKitVectorProc(void) { if (verbose) puts("STUB: DIMediaKitVectorProc called"); return NULL; }
void* DIMediaKitVectorProcWithOffset(void) { if (verbose) puts("STUB: DIMediaKitVectorProcWithOffset called"); return NULL; }
void* DIMountPointGetInformation(void) { if (verbose) puts("STUB: DIMountPointGetInformation called"); return NULL; }
void* DINDIFDiskImageGetNDIFHeader(void) { if (verbose) puts("STUB: DINDIFDiskImageGetNDIFHeader called"); return NULL; }
void* DIPartitionSchemeScan(void) { if (verbose) puts("STUB: DIPartitionSchemeScan called"); return NULL; }
void* DIRawDevEntryToBlockDevice(void) { if (verbose) puts("STUB: DIRawDevEntryToBlockDevice called"); return NULL; }
void* DIResolveBackingStoreToDiskImage(void) { if (verbose) puts("STUB: DIResolveBackingStoreToDiskImage called"); return NULL; }
void* DIResolvePathsToDiskImage(void) { if (verbose) puts("STUB: DIResolvePathsToDiskImage called"); return NULL; }
void* DIResolvePathsToDiskImageWithOptions(void) { if (verbose) puts("STUB: DIResolvePathsToDiskImageWithOptions called"); return NULL; }
void* DIResolveURLToBackingStore(void) { if (verbose) puts("STUB: DIResolveURLToBackingStore called"); return NULL; }
void* DIResolveURLToDiskImage(void) { if (verbose) puts("STUB: DIResolveURLToDiskImage called"); return NULL; }
void* DIResourceFileAddResource(void) { if (verbose) puts("STUB: DIResourceFileAddResource called"); return NULL; }
void* DIResourceFileChangedResource(void) { if (verbose) puts("STUB: DIResourceFileChangedResource called"); return NULL; }
void* DIResourceFileCopyResourcesFrom(void) { if (verbose) puts("STUB: DIResourceFileCopyResourcesFrom called"); return NULL; }
void* DIResourceFileCopyXMLRepresentation(void) { if (verbose) puts("STUB: DIResourceFileCopyXMLRepresentation called"); return NULL; }
void* DIResourceFileCountResources(void) { if (verbose) puts("STUB: DIResourceFileCountResources called"); return NULL; }
void* DIResourceFileCountTypes(void) { if (verbose) puts("STUB: DIResourceFileCountTypes called"); return NULL; }
void* DIResourceFileCreateWithXMLRepresentation(void) { if (verbose) puts("STUB: DIResourceFileCreateWithXMLRepresentation called"); return NULL; }
void* DIResourceFileDeleteAllResources(void) { if (verbose) puts("STUB: DIResourceFileDeleteAllResources called"); return NULL; }
void* DIResourceFileDeleteAllResourcesOfType(void) { if (verbose) puts("STUB: DIResourceFileDeleteAllResourcesOfType called"); return NULL; }
void* DIResourceFileDetachResource(void) { if (verbose) puts("STUB: DIResourceFileDetachResource called"); return NULL; }
void* DIResourceFileGetIndResource(void) { if (verbose) puts("STUB: DIResourceFileGetIndResource called"); return NULL; }
void* DIResourceFileGetIndType(void) { if (verbose) puts("STUB: DIResourceFileGetIndType called"); return NULL; }
void* DIResourceFileGetResAttrs(void) { if (verbose) puts("STUB: DIResourceFileGetResAttrs called"); return NULL; }
void* DIResourceFileGetResInfo(void) { if (verbose) puts("STUB: DIResourceFileGetResInfo called"); return NULL; }
void* DIResourceFileGetResource(void) { if (verbose) puts("STUB: DIResourceFileGetResource called"); return NULL; }
void* DIResourceFileReleaseResource(void) { if (verbose) puts("STUB: DIResourceFileReleaseResource called"); return NULL; }
void* DIResourceFileSetResAttrs(void) { if (verbose) puts("STUB: DIResourceFileSetResAttrs called"); return NULL; }
void* DIResourceFileSetResInfo(void) { if (verbose) puts("STUB: DIResourceFileSetResInfo called"); return NULL; }
void* DIResourceFileUpdateResFile(void) { if (verbose) puts("STUB: DIResourceFileUpdateResFile called"); return NULL; }
void* DIResourceFileWriteResource(void) { if (verbose) puts("STUB: DIResourceFileWriteResource called"); return NULL; }
void* DISetDebugLevel(void) { if (verbose) puts("STUB: DISetDebugLevel called"); return NULL; }
void* DISetVerboseLevel(void) { if (verbose) puts("STUB: DISetVerboseLevel called"); return NULL; }
void* DIShadowedDiskImageCopyDefaultShadowFileURL(void) { if (verbose) puts("STUB: DIShadowedDiskImageCopyDefaultShadowFileURL called"); return NULL; }
void* DIShadowedDiskImageCreateDefaultShadowFileName(void) { if (verbose) puts("STUB: DIShadowedDiskImageCreateDefaultShadowFileName called"); return NULL; }
void* DIShadowedDiskImageNewWithDiskImageAndShadowURL(void) { if (verbose) puts("STUB: DIShadowedDiskImageNewWithDiskImageAndShadowURL called"); return NULL; }
void* DIStrError(void) { if (verbose) puts("STUB: DIStrError called"); return NULL; }
void* DIStrError_r(void) { if (verbose) puts("STUB: DIStrError_r called"); return NULL; }
void* DISubDiskImageCreateNewWithDiskImage(void) { if (verbose) puts("STUB: DISubDiskImageCreateNewWithDiskImage called"); return NULL; }
void* DIUDIFDiskImageGetBLKX(void) { if (verbose) puts("STUB: DIUDIFDiskImageGetBLKX called"); return NULL; }
void* DIUDIFDiskImageGetBLKXStartingAt(void) { if (verbose) puts("STUB: DIUDIFDiskImageGetBLKXStartingAt called"); return NULL; }
void* DIUDIFDiskImageGetImageVariant(void) { if (verbose) puts("STUB: DIUDIFDiskImageGetImageVariant called"); return NULL; }
void* DIUDIFDiskImageGetUDIFFileHeader(void) { if (verbose) puts("STUB: DIUDIFDiskImageGetUDIFFileHeader called"); return NULL; }
void* DIUDIFFileAccessAppendData(void) { if (verbose) puts("STUB: DIUDIFFileAccessAppendData called"); return NULL; }
void* DIUDIFFileAccessCloseFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessCloseFile called"); return NULL; }
void* DIUDIFFileAccessCreateWithCFURL(void) { if (verbose) puts("STUB: DIUDIFFileAccessCreateWithCFURL called"); return NULL; }
void* DIUDIFFileAccessDelete(void) { if (verbose) puts("STUB: DIUDIFFileAccessDelete called"); return NULL; }
void* DIUDIFFileAccessDeleteFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessDeleteFile called"); return NULL; }
void* DIUDIFFileAccessFlattenFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessFlattenFile called"); return NULL; }
void* DIUDIFFileAccessFlattenFileWithEmbedOptions(void) { if (verbose) puts("STUB: DIUDIFFileAccessFlattenFileWithEmbedOptions called"); return NULL; }
void* DIUDIFFileAccessGetBackingStore(void) { if (verbose) puts("STUB: DIUDIFFileAccessGetBackingStore called"); return NULL; }
void* DIUDIFFileAccessGetHeaderStyle(void) { if (verbose) puts("STUB: DIUDIFFileAccessGetHeaderStyle called"); return NULL; }
void* DIUDIFFileAccessGetResourceFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessGetResourceFile called"); return NULL; }
void* DIUDIFFileAccessGetUDIFFileHeader(void) { if (verbose) puts("STUB: DIUDIFFileAccessGetUDIFFileHeader called"); return NULL; }
void* DIUDIFFileAccessNewWithCFURL(void) { if (verbose) puts("STUB: DIUDIFFileAccessNewWithCFURL called"); return NULL; }
void* DIUDIFFileAccessOpenFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessOpenFile called"); return NULL; }
void* DIUDIFFileAccessSetMaxSectorsPerSegment(void) { if (verbose) puts("STUB: DIUDIFFileAccessSetMaxSectorsPerSegment called"); return NULL; }
void* DIUDIFFileAccessUnflattenFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessUnflattenFile called"); return NULL; }
void* DIUDIFFileAccessUpdateHeader(void) { if (verbose) puts("STUB: DIUDIFFileAccessUpdateHeader called"); return NULL; }
void* DIUDIFFileAccessWriteResourceFile(void) { if (verbose) puts("STUB: DIUDIFFileAccessWriteResourceFile called"); return NULL; }
void* DIUDIFFileAccessWriteResourceFileAsCarbonResourceFork(void) { if (verbose) puts("STUB: DIUDIFFileAccessWriteResourceFileAsCarbonResourceFork called"); return NULL; }
void* DIUDIFFileAccessWriteResourceFileAsXML(void) { if (verbose) puts("STUB: DIUDIFFileAccessWriteResourceFileAsXML called"); return NULL; }
void* DIVRefNumGetInformation(void) { if (verbose) puts("STUB: DIVRefNumGetInformation called"); return NULL; }
void* DI_kextConnect(void) { if (verbose) puts("STUB: DI_kextConnect called"); return NULL; }
void* DI_kextCreateDrive(void) { if (verbose) puts("STUB: DI_kextCreateDrive called"); return NULL; }
void* DI_kextCreateDriveInKernel(void) { if (verbose) puts("STUB: DI_kextCreateDriveInKernel called"); return NULL; }
void* DI_kextDisconnect(void) { if (verbose) puts("STUB: DI_kextDisconnect called"); return NULL; }
void* DI_kextDriveActivate(void) { if (verbose) puts("STUB: DI_kextDriveActivate called"); return NULL; }
void* DI_kextDriveConnect(void) { if (verbose) puts("STUB: DI_kextDriveConnect called"); return NULL; }
void* DI_kextDriveDisconnect(void) { if (verbose) puts("STUB: DI_kextDriveDisconnect called"); return NULL; }
void* DI_kextDriveGetRequest(void) { if (verbose) puts("STUB: DI_kextDriveGetRequest called"); return NULL; }
void* DI_kextDrivePutReply(void) { if (verbose) puts("STUB: DI_kextDrivePutReply called"); return NULL; }
void* DI_kextDriveRegisterClientBuffer(void) { if (verbose) puts("STUB: DI_kextDriveRegisterClientBuffer called"); return NULL; }
void* DI_kextExists(void) { if (verbose) puts("STUB: DI_kextExists called"); return NULL; }
void* DI_kextTestNetBootHook(void) { if (verbose) puts("STUB: DI_kextTestNetBootHook called"); return NULL; }
void* DI_kextWaitQuiet(void) { if (verbose) puts("STUB: DI_kextWaitQuiet called"); return NULL; }
void* DI_logBuffer(void) { if (verbose) puts("STUB: DI_logBuffer called"); return NULL; }
void* DI_logDARTHeader(void) { if (verbose) puts("STUB: DI_logDARTHeader called"); return NULL; }
void* DI_logDiskCopy42Header(void) { if (verbose) puts("STUB: DI_logDiskCopy42Header called"); return NULL; }
void* DI_logHDIChecksum(void) { if (verbose) puts("STUB: DI_logHDIChecksum called"); return NULL; }
void* DI_logHDIReply64(void) { if (verbose) puts("STUB: DI_logHDIReply64 called"); return NULL; }
void* DI_logHDIRequest64(void) { if (verbose) puts("STUB: DI_logHDIRequest64 called"); return NULL; }
void* DI_logHDISegmentID(void) { if (verbose) puts("STUB: DI_logHDISegmentID called"); return NULL; }
void* DI_logHFSPlusForkData(void) { if (verbose) puts("STUB: DI_logHFSPlusForkData called"); return NULL; }
void* DI_logMDB(void) { if (verbose) puts("STUB: DI_logMDB called"); return NULL; }
void* DI_logMDB_to_file(void) { if (verbose) puts("STUB: DI_logMDB_to_file called"); return NULL; }
void* DI_logNDIFHeader(void) { if (verbose) puts("STUB: DI_logNDIFHeader called"); return NULL; }
void* DI_logNDIFSegmentInfo(void) { if (verbose) puts("STUB: DI_logNDIFSegmentInfo called"); return NULL; }
void* DI_logNDIFSourceSubTable(void) { if (verbose) puts("STUB: DI_logNDIFSourceSubTable called"); return NULL; }
void* DI_logUDIFFileHeader(void) { if (verbose) puts("STUB: DI_logUDIFFileHeader called"); return NULL; }
void* DI_logUDIFPartitionList(void) { if (verbose) puts("STUB: DI_logUDIFPartitionList called"); return NULL; }
void* DI_logUDIFRun(void) { if (verbose) puts("STUB: DI_logUDIFRun called"); return NULL; }
void* DI_logUDIFblkx(void) { if (verbose) puts("STUB: DI_logUDIFblkx called"); return NULL; }
void* DI_logUDIFblkx_ptr(void) { if (verbose) puts("STUB: DI_logUDIFblkx_ptr called"); return NULL; }
void* DI_logVH(void) { if (verbose) puts("STUB: DI_logVH called"); return NULL; }
void* DI_logVH_to_file(void) { if (verbose) puts("STUB: DI_logVH_to_file called"); return NULL; }
void* MKCalculatePartitionParameters(void) { if (verbose) puts("STUB: MKCalculatePartitionParameters called"); return NULL; }
void* MKCopyDefaultLayouts(void) { if (verbose) puts("STUB: MKCopyDefaultLayouts called"); return NULL; }
void* MKCopyLayoutInfoArrayWithOverhead(void) { if (verbose) puts("STUB: MKCopyLayoutInfoArrayWithOverhead called"); return NULL; }