#ifndef QFMOD_H

 #define QFMOD_H

 #include "fmod.h"

 extern FMOD_RESULT (F_API *qFMOD_Memory_Initialize)(void *poolmem, int poollen, FMOD_MEMORY_ALLOCCALLBACK useralloc, FMOD_MEMORY_REALLOCCALLBACK userrealloc, FMOD_MEMORY_FREECALLBACK userfree, FMOD_MEMORY_TYPE memtypeflags);

 extern FMOD_RESULT (F_API *qFMOD_Memory_GetStats)(int *currentalloced, int *maxalloced, FMOD_BOOL blocking);

 extern FMOD_RESULT (F_API *qFMOD_Debug_SetLevel)(FMOD_DEBUGLEVEL level);

 extern FMOD_RESULT (F_API *qFMOD_Debug_GetLevel)(FMOD_DEBUGLEVEL *level);

 extern FMOD_RESULT (F_API *qFMOD_File_SetDiskBusy)(int busy);

 extern FMOD_RESULT (F_API *qFMOD_File_GetDiskBusy)(int *busy);

 extern FMOD_RESULT (F_API *qFMOD_System_Create)(FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_System_Release)(FMOD_SYSTEM *system);

 extern FMOD_RESULT (F_API *qFMOD_System_SetOutput)(FMOD_SYSTEM *system, FMOD_OUTPUTTYPE output);

 extern FMOD_RESULT (F_API *qFMOD_System_GetOutput)(FMOD_SYSTEM *system, FMOD_OUTPUTTYPE *output);

 extern FMOD_RESULT (F_API *qFMOD_System_GetNumDrivers)(FMOD_SYSTEM *system, int *numdrivers);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDriverInfo)(FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDriverInfoW)(FMOD_SYSTEM *system, int id, short *name, int namelen, FMOD_GUID *guid);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDriverCaps)(FMOD_SYSTEM *system, int id, FMOD_CAPS *caps, int *controlpaneloutputrate, FMOD_SPEAKERMODE *controlpanelspeakermode);

 extern FMOD_RESULT (F_API *qFMOD_System_SetDriver)(FMOD_SYSTEM *system, int driver);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDriver)(FMOD_SYSTEM *system, int *driver);

 extern FMOD_RESULT (F_API *qFMOD_System_SetHardwareChannels)(FMOD_SYSTEM *system, int numhardwarechannels);

 extern FMOD_RESULT (F_API *qFMOD_System_SetSoftwareChannels)(FMOD_SYSTEM *system, int numsoftwarechannels);

 extern FMOD_RESULT (F_API *qFMOD_System_GetSoftwareChannels)(FMOD_SYSTEM *system, int *numsoftwarechannels);

 extern FMOD_RESULT (F_API *qFMOD_System_SetSoftwareFormat)(FMOD_SYSTEM *system, int samplerate, FMOD_SOUND_FORMAT format, int numoutputchannels, int maxinputchannels, FMOD_DSP_RESAMPLER resamplemethod);

 extern FMOD_RESULT (F_API *qFMOD_System_GetSoftwareFormat)(FMOD_SYSTEM *system, int *samplerate, FMOD_SOUND_FORMAT *format, int *numoutputchannels, int *maxinputchannels, FMOD_DSP_RESAMPLER *resamplemethod, int *bits);

 extern FMOD_RESULT (F_API *qFMOD_System_SetDSPBufferSize)(FMOD_SYSTEM *system, unsigned int bufferlength, int numbuffers);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDSPBufferSize)(FMOD_SYSTEM *system, unsigned int *bufferlength, int *numbuffers);

 extern FMOD_RESULT (F_API *qFMOD_System_SetFileSystem)(FMOD_SYSTEM *system, FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek, FMOD_FILE_ASYNCREADCALLBACK userasyncread, FMOD_FILE_ASYNCCANCELCALLBACK userasynccancel, int blockalign);

 extern FMOD_RESULT (F_API *qFMOD_System_AttachFileSystem)(FMOD_SYSTEM *system, FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek);

 extern FMOD_RESULT (F_API *qFMOD_System_SetAdvancedSettings)(FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings);

 extern FMOD_RESULT (F_API *qFMOD_System_GetAdvancedSettings)(FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings);

 extern FMOD_RESULT (F_API *qFMOD_System_SetSpeakerMode)(FMOD_SYSTEM *system, FMOD_SPEAKERMODE speakermode);

 extern FMOD_RESULT (F_API *qFMOD_System_GetSpeakerMode)(FMOD_SYSTEM *system, FMOD_SPEAKERMODE *speakermode);

 extern FMOD_RESULT (F_API *qFMOD_System_SetCallback)(FMOD_SYSTEM *system, FMOD_SYSTEM_CALLBACK callback);

 extern FMOD_RESULT (F_API *qFMOD_System_SetPluginPath)(FMOD_SYSTEM *system, const char *path);

 extern FMOD_RESULT (F_API *qFMOD_System_LoadPlugin)(FMOD_SYSTEM *system, const char *filename, unsigned int *handle, unsigned int priority);

 extern FMOD_RESULT (F_API *qFMOD_System_UnloadPlugin)(FMOD_SYSTEM *system, unsigned int handle);

 extern FMOD_RESULT (F_API *qFMOD_System_GetNumPlugins)(FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int *numplugins);

 extern FMOD_RESULT (F_API *qFMOD_System_GetPluginHandle)(FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int index, unsigned int *handle);

 extern FMOD_RESULT (F_API *qFMOD_System_GetPluginInfo)(FMOD_SYSTEM *system, unsigned int handle, FMOD_PLUGINTYPE *plugintype, char *name, int namelen, unsigned int *version);

 extern FMOD_RESULT (F_API *qFMOD_System_SetOutputByPlugin)(FMOD_SYSTEM *system, unsigned int handle);

 extern FMOD_RESULT (F_API *qFMOD_System_GetOutputByPlugin)(FMOD_SYSTEM *system, unsigned int *handle);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateDSPByPlugin)(FMOD_SYSTEM *system, unsigned int handle, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_System_RegisterCodec)(FMOD_SYSTEM *system, FMOD_CODEC_DESCRIPTION *description, unsigned int *handle, unsigned int priority);

 extern FMOD_RESULT (F_API *qFMOD_System_RegisterDSP)(FMOD_SYSTEM *system, FMOD_DSP_DESCRIPTION *description, unsigned int *handle);

 extern FMOD_RESULT (F_API *qFMOD_System_Init)(FMOD_SYSTEM *system, int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata);

 extern FMOD_RESULT (F_API *qFMOD_System_Close)(FMOD_SYSTEM *system);

 extern FMOD_RESULT (F_API *qFMOD_System_Update)(FMOD_SYSTEM *system);

 extern FMOD_RESULT (F_API *qFMOD_System_Set3DSettings)(FMOD_SYSTEM *system, float dopplerscale, float distancefactor, float rolloffscale);

 extern FMOD_RESULT (F_API *qFMOD_System_Get3DSettings)(FMOD_SYSTEM *system, float *dopplerscale, float *distancefactor, float *rolloffscale);

 extern FMOD_RESULT (F_API *qFMOD_System_Set3DNumListeners)(FMOD_SYSTEM *system, int numlisteners);

 extern FMOD_RESULT (F_API *qFMOD_System_Get3DNumListeners)(FMOD_SYSTEM *system, int *numlisteners);

 extern FMOD_RESULT (F_API *qFMOD_System_Set3DListenerAttributes)(FMOD_SYSTEM *system, int listener, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel, const FMOD_VECTOR *forward, const FMOD_VECTOR *up);

 extern FMOD_RESULT (F_API *qFMOD_System_Get3DListenerAttributes)(FMOD_SYSTEM *system, int listener, FMOD_VECTOR *pos, FMOD_VECTOR *vel, FMOD_VECTOR *forward, FMOD_VECTOR *up);

 extern FMOD_RESULT (F_API *qFMOD_System_Set3DRolloffCallback)(FMOD_SYSTEM *system, FMOD_3D_ROLLOFFCALLBACK callback);

 extern FMOD_RESULT (F_API *qFMOD_System_Set3DSpeakerPosition)(FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float x, float y, FMOD_BOOL active);

 extern FMOD_RESULT (F_API *qFMOD_System_Get3DSpeakerPosition)(FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float *x, float *y, FMOD_BOOL *active);

 extern FMOD_RESULT (F_API *qFMOD_System_SetStreamBufferSize)(FMOD_SYSTEM *system, unsigned int filebuffersize, FMOD_TIMEUNIT filebuffersizetype);

 extern FMOD_RESULT (F_API *qFMOD_System_GetStreamBufferSize)(FMOD_SYSTEM *system, unsigned int *filebuffersize, FMOD_TIMEUNIT *filebuffersizetype);

 extern FMOD_RESULT (F_API *qFMOD_System_GetVersion)(FMOD_SYSTEM *system, unsigned int *version);

 extern FMOD_RESULT (F_API *qFMOD_System_GetOutputHandle)(FMOD_SYSTEM *system, void **handle);

 extern FMOD_RESULT (F_API *qFMOD_System_GetChannelsPlaying)(FMOD_SYSTEM *system, int *channels);

 extern FMOD_RESULT (F_API *qFMOD_System_GetHardwareChannels)(FMOD_SYSTEM *system, int *numhardwarechannels);

 extern FMOD_RESULT (F_API *qFMOD_System_GetCPUUsage)(FMOD_SYSTEM *system, float *dsp, float *stream, float *geometry, float *update, float *total);

 extern FMOD_RESULT (F_API *qFMOD_System_GetSoundRAM)(FMOD_SYSTEM *system, int *currentalloced, int *maxalloced, int *total);

 extern FMOD_RESULT (F_API *qFMOD_System_GetNumCDROMDrives)(FMOD_SYSTEM *system, int *numdrives);

 extern FMOD_RESULT (F_API *qFMOD_System_GetCDROMDriveName)(FMOD_SYSTEM *system, int drive, char *drivename, int drivenamelen, char *scsiname, int scsinamelen, char *devicename, int devicenamelen);

 extern FMOD_RESULT (F_API *qFMOD_System_GetSpectrum)(FMOD_SYSTEM *system, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);

 extern FMOD_RESULT (F_API *qFMOD_System_GetWaveData)(FMOD_SYSTEM *system, float *wavearray, int numvalues, int channeloffset);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateSound)(FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateStream)(FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateDSP)(FMOD_SYSTEM *system, FMOD_DSP_DESCRIPTION *description, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateDSPByType)(FMOD_SYSTEM *system, FMOD_DSP_TYPE type, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateChannelGroup)(FMOD_SYSTEM *system, const char *name, FMOD_CHANNELGROUP **channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateSoundGroup)(FMOD_SYSTEM *system, const char *name, FMOD_SOUNDGROUP **soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateReverb)(FMOD_SYSTEM *system, FMOD_REVERB **reverb);

 extern FMOD_RESULT (F_API *qFMOD_System_PlaySound)(FMOD_SYSTEM *system, FMOD_CHANNELINDEX channelid, FMOD_SOUND *sound, FMOD_BOOL paused, FMOD_CHANNEL **channel);

 extern FMOD_RESULT (F_API *qFMOD_System_PlayDSP)(FMOD_SYSTEM *system, FMOD_CHANNELINDEX channelid, FMOD_DSP *dsp, FMOD_BOOL paused, FMOD_CHANNEL **channel);

 extern FMOD_RESULT (F_API *qFMOD_System_GetChannel)(FMOD_SYSTEM *system, int channelid, FMOD_CHANNEL **channel);

 extern FMOD_RESULT (F_API *qFMOD_System_GetMasterChannelGroup)(FMOD_SYSTEM *system, FMOD_CHANNELGROUP **channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_System_GetMasterSoundGroup)(FMOD_SYSTEM *system, FMOD_SOUNDGROUP **soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_System_SetReverbProperties)(FMOD_SYSTEM *system, const FMOD_REVERB_PROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_System_GetReverbProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_System_SetReverbAmbientProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_System_GetReverbAmbientProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDSPHead)(FMOD_SYSTEM *system, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_System_AddDSP)(FMOD_SYSTEM *system, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection);

 extern FMOD_RESULT (F_API *qFMOD_System_LockDSP)(FMOD_SYSTEM *system);

 extern FMOD_RESULT (F_API *qFMOD_System_UnlockDSP)(FMOD_SYSTEM *system);

 extern FMOD_RESULT (F_API *qFMOD_System_GetDSPClock)(FMOD_SYSTEM *system, unsigned int *hi, unsigned int *lo);

 extern FMOD_RESULT (F_API *qFMOD_System_GetRecordNumDrivers)(FMOD_SYSTEM *system, int *numdrivers);

 extern FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverInfo)(FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid);

 extern FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverInfoW)(FMOD_SYSTEM *system, int id, short *name, int namelen, FMOD_GUID *guid);

 extern FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverCaps)(FMOD_SYSTEM *system, int id, FMOD_CAPS *caps, int *minfrequency, int *maxfrequency);

 extern FMOD_RESULT (F_API *qFMOD_System_GetRecordPosition)(FMOD_SYSTEM *system, int id, unsigned int *position);

 extern FMOD_RESULT (F_API *qFMOD_System_RecordStart)(FMOD_SYSTEM *system, int id, FMOD_SOUND *sound, FMOD_BOOL loop);

 extern FMOD_RESULT (F_API *qFMOD_System_RecordStop)(FMOD_SYSTEM *system, int id);

 extern FMOD_RESULT (F_API *qFMOD_System_IsRecording)(FMOD_SYSTEM *system, int id, FMOD_BOOL *recording);

 extern FMOD_RESULT (F_API *qFMOD_System_CreateGeometry)(FMOD_SYSTEM *system, int maxpolygons, int maxvertices, FMOD_GEOMETRY **geometry);

 extern FMOD_RESULT (F_API *qFMOD_System_SetGeometrySettings)(FMOD_SYSTEM *system, float maxworldsize);

 extern FMOD_RESULT (F_API *qFMOD_System_GetGeometrySettings)(FMOD_SYSTEM *system, float *maxworldsize);

 extern FMOD_RESULT (F_API *qFMOD_System_LoadGeometry)(FMOD_SYSTEM *system, const void *data, int datasize, FMOD_GEOMETRY **geometry);

 extern FMOD_RESULT (F_API *qFMOD_System_GetGeometryOcclusion)(FMOD_SYSTEM *system, const FMOD_VECTOR *listener, const FMOD_VECTOR *source, float *direct, float *reverb);

 extern FMOD_RESULT (F_API *qFMOD_System_SetNetworkProxy)(FMOD_SYSTEM *system, const char *proxy);

 extern FMOD_RESULT (F_API *qFMOD_System_GetNetworkProxy)(FMOD_SYSTEM *system, char *proxy, int proxylen);

 extern FMOD_RESULT (F_API *qFMOD_System_SetNetworkTimeout)(FMOD_SYSTEM *system, int timeout);

 extern FMOD_RESULT (F_API *qFMOD_System_GetNetworkTimeout)(FMOD_SYSTEM *system, int *timeout);

 extern FMOD_RESULT (F_API *qFMOD_System_SetUserData)(FMOD_SYSTEM *system, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_System_GetUserData)(FMOD_SYSTEM *system, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_System_GetMemoryInfo)(FMOD_SYSTEM *system, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Release)(FMOD_SOUND *sound);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSystemObject)(FMOD_SOUND *sound, FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Lock)(FMOD_SOUND *sound, unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Unlock)(FMOD_SOUND *sound, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetDefaults)(FMOD_SOUND *sound, float frequency, float volume, float pan, int priority);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetDefaults)(FMOD_SOUND *sound, float *frequency, float *volume, float *pan, int *priority);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetVariations)(FMOD_SOUND *sound, float frequencyvar, float volumevar, float panvar);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetVariations)(FMOD_SOUND *sound, float *frequencyvar, float *volumevar, float *panvar);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Set3DMinMaxDistance)(FMOD_SOUND *sound, float min, float max);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Get3DMinMaxDistance)(FMOD_SOUND *sound, float *min, float *max);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Set3DConeSettings)(FMOD_SOUND *sound, float insideconeangle, float outsideconeangle, float outsidevolume);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Get3DConeSettings)(FMOD_SOUND *sound, float *insideconeangle, float *outsideconeangle, float *outsidevolume);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Set3DCustomRolloff)(FMOD_SOUND *sound, FMOD_VECTOR *points, int numpoints);

 extern FMOD_RESULT (F_API *qFMOD_Sound_Get3DCustomRolloff)(FMOD_SOUND *sound, FMOD_VECTOR **points, int *numpoints);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetSubSound)(FMOD_SOUND *sound, int index, FMOD_SOUND *subsound);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSubSound)(FMOD_SOUND *sound, int index, FMOD_SOUND **subsound);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSubSoundParent)(FMOD_SOUND *sound, FMOD_SOUND **parentsound);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetSubSoundSentence)(FMOD_SOUND *sound, int *subsoundlist, int numsubsounds);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetName)(FMOD_SOUND *sound, char *name, int namelen);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetLength)(FMOD_SOUND *sound, unsigned int *length, FMOD_TIMEUNIT lengthtype);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetFormat)(FMOD_SOUND *sound, FMOD_SOUND_TYPE *type, FMOD_SOUND_FORMAT *format, int *channels, int *bits);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetNumSubSounds)(FMOD_SOUND *sound, int *numsubsounds);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetNumTags)(FMOD_SOUND *sound, int *numtags, int *numtagsupdated);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetTag)(FMOD_SOUND *sound, const char *name, int index, FMOD_TAG *tag);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetOpenState)(FMOD_SOUND *sound, FMOD_OPENSTATE *openstate, unsigned int *percentbuffered, FMOD_BOOL *starving, FMOD_BOOL *diskbusy);

 extern FMOD_RESULT (F_API *qFMOD_Sound_ReadData)(FMOD_SOUND *sound, void *buffer, unsigned int lenbytes, unsigned int *read);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SeekData)(FMOD_SOUND *sound, unsigned int pcm);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetSoundGroup)(FMOD_SOUND *sound, FMOD_SOUNDGROUP *soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSoundGroup)(FMOD_SOUND *sound, FMOD_SOUNDGROUP **soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetNumSyncPoints)(FMOD_SOUND *sound, int *numsyncpoints);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSyncPoint)(FMOD_SOUND *sound, int index, FMOD_SYNCPOINT **point);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetSyncPointInfo)(FMOD_SOUND *sound, FMOD_SYNCPOINT *point, char *name, int namelen, unsigned int *offset, FMOD_TIMEUNIT offsettype);

 extern FMOD_RESULT (F_API *qFMOD_Sound_AddSyncPoint)(FMOD_SOUND *sound, unsigned int offset, FMOD_TIMEUNIT offsettype, const char *name, FMOD_SYNCPOINT **point);

 extern FMOD_RESULT (F_API *qFMOD_Sound_DeleteSyncPoint)(FMOD_SOUND *sound, FMOD_SYNCPOINT *point);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetMode)(FMOD_SOUND *sound, FMOD_MODE mode);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetMode)(FMOD_SOUND *sound, FMOD_MODE *mode);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetLoopCount)(FMOD_SOUND *sound, int loopcount);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetLoopCount)(FMOD_SOUND *sound, int *loopcount);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetLoopPoints)(FMOD_SOUND *sound, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetLoopPoints)(FMOD_SOUND *sound, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetMusicNumChannels)(FMOD_SOUND *sound, int *numchannels);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetMusicChannelVolume)(FMOD_SOUND *sound, int channel, float volume);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetMusicChannelVolume)(FMOD_SOUND *sound, int channel, float *volume);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetMusicSpeed)(FMOD_SOUND *sound, float speed);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetMusicSpeed)(FMOD_SOUND *sound, float *speed);

 extern FMOD_RESULT (F_API *qFMOD_Sound_SetUserData)(FMOD_SOUND *sound, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetUserData)(FMOD_SOUND *sound, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_Sound_GetMemoryInfo)(FMOD_SOUND *sound, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetSystemObject)(FMOD_CHANNEL *channel, FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Stop)(FMOD_CHANNEL *channel);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetPaused)(FMOD_CHANNEL *channel, FMOD_BOOL paused);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetPaused)(FMOD_CHANNEL *channel, FMOD_BOOL *paused);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetVolume)(FMOD_CHANNEL *channel, float volume);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetVolume)(FMOD_CHANNEL *channel, float *volume);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetFrequency)(FMOD_CHANNEL *channel, float frequency);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetFrequency)(FMOD_CHANNEL *channel, float *frequency);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetPan)(FMOD_CHANNEL *channel, float pan);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetPan)(FMOD_CHANNEL *channel, float *pan);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetDelay)(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int delayhi, unsigned int delaylo);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetDelay)(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int *delayhi, unsigned int *delaylo);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetSpeakerMix)(FMOD_CHANNEL *channel, float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetSpeakerMix)(FMOD_CHANNEL *channel, float *frontleft, float *frontright, float *center, float *lfe, float *backleft, float *backright, float *sideleft, float *sideright);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetSpeakerLevels)(FMOD_CHANNEL *channel, FMOD_SPEAKER speaker, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetSpeakerLevels)(FMOD_CHANNEL *channel, FMOD_SPEAKER speaker, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetInputChannelMix)(FMOD_CHANNEL *channel, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetInputChannelMix)(FMOD_CHANNEL *channel, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetMute)(FMOD_CHANNEL *channel, FMOD_BOOL mute);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetMute)(FMOD_CHANNEL *channel, FMOD_BOOL *mute);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetPriority)(FMOD_CHANNEL *channel, int priority);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetPriority)(FMOD_CHANNEL *channel, int *priority);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetPosition)(FMOD_CHANNEL *channel, unsigned int position, FMOD_TIMEUNIT postype);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetPosition)(FMOD_CHANNEL *channel, unsigned int *position, FMOD_TIMEUNIT postype);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetReverbProperties)(FMOD_CHANNEL *channel, const FMOD_REVERB_CHANNELPROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetReverbProperties)(FMOD_CHANNEL *channel, FMOD_REVERB_CHANNELPROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetLowPassGain)(FMOD_CHANNEL *channel, float gain);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetLowPassGain)(FMOD_CHANNEL *channel, float *gain);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetChannelGroup)(FMOD_CHANNEL *channel, FMOD_CHANNELGROUP *channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetChannelGroup)(FMOD_CHANNEL *channel, FMOD_CHANNELGROUP **channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetCallback)(FMOD_CHANNEL *channel, FMOD_CHANNEL_CALLBACK callback);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DAttributes)(FMOD_CHANNEL *channel, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DAttributes)(FMOD_CHANNEL *channel, FMOD_VECTOR *pos, FMOD_VECTOR *vel);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DMinMaxDistance)(FMOD_CHANNEL *channel, float mindistance, float maxdistance);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DMinMaxDistance)(FMOD_CHANNEL *channel, float *mindistance, float *maxdistance);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DConeSettings)(FMOD_CHANNEL *channel, float insideconeangle, float outsideconeangle, float outsidevolume);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DConeSettings)(FMOD_CHANNEL *channel, float *insideconeangle, float *outsideconeangle, float *outsidevolume);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DConeOrientation)(FMOD_CHANNEL *channel, FMOD_VECTOR *orientation);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DConeOrientation)(FMOD_CHANNEL *channel, FMOD_VECTOR *orientation);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DCustomRolloff)(FMOD_CHANNEL *channel, FMOD_VECTOR *points, int numpoints);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DCustomRolloff)(FMOD_CHANNEL *channel, FMOD_VECTOR **points, int *numpoints);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DOcclusion)(FMOD_CHANNEL *channel, float directocclusion, float reverbocclusion);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DOcclusion)(FMOD_CHANNEL *channel, float *directocclusion, float *reverbocclusion);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DSpread)(FMOD_CHANNEL *channel, float angle);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DSpread)(FMOD_CHANNEL *channel, float *angle);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DPanLevel)(FMOD_CHANNEL *channel, float level);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DPanLevel)(FMOD_CHANNEL *channel, float *level);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DDopplerLevel)(FMOD_CHANNEL *channel, float level);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DDopplerLevel)(FMOD_CHANNEL *channel, float *level);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Set3DDistanceFilter)(FMOD_CHANNEL *channel, FMOD_BOOL custom, float customLevel, float centerFreq);

 extern FMOD_RESULT (F_API *qFMOD_Channel_Get3DDistanceFilter)(FMOD_CHANNEL *channel, FMOD_BOOL *custom, float *customLevel, float *centerFreq);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetDSPHead)(FMOD_CHANNEL *channel, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_Channel_AddDSP)(FMOD_CHANNEL *channel, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection);

 extern FMOD_RESULT (F_API *qFMOD_Channel_IsPlaying)(FMOD_CHANNEL *channel, FMOD_BOOL *isplaying);

 extern FMOD_RESULT (F_API *qFMOD_Channel_IsVirtual)(FMOD_CHANNEL *channel, FMOD_BOOL *isvirtual);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetAudibility)(FMOD_CHANNEL *channel, float *audibility);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetCurrentSound)(FMOD_CHANNEL *channel, FMOD_SOUND **sound);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetSpectrum)(FMOD_CHANNEL *channel, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetWaveData)(FMOD_CHANNEL *channel, float *wavearray, int numvalues, int channeloffset);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetIndex)(FMOD_CHANNEL *channel, int *index);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetMode)(FMOD_CHANNEL *channel, FMOD_MODE mode);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetMode)(FMOD_CHANNEL *channel, FMOD_MODE *mode);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetLoopCount)(FMOD_CHANNEL *channel, int loopcount);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetLoopCount)(FMOD_CHANNEL *channel, int *loopcount);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetLoopPoints)(FMOD_CHANNEL *channel, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetLoopPoints)(FMOD_CHANNEL *channel, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype);

 extern FMOD_RESULT (F_API *qFMOD_Channel_SetUserData)(FMOD_CHANNEL *channel, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetUserData)(FMOD_CHANNEL *channel, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_Channel_GetMemoryInfo)(FMOD_CHANNEL *channel, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_Release)(FMOD_CHANNELGROUP *channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetSystemObject)(FMOD_CHANNELGROUP *channelgroup, FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetVolume)(FMOD_CHANNELGROUP *channelgroup, float volume);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetVolume)(FMOD_CHANNELGROUP *channelgroup, float *volume);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetPitch)(FMOD_CHANNELGROUP *channelgroup, float pitch);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetPitch)(FMOD_CHANNELGROUP *channelgroup, float *pitch);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_Set3DOcclusion)(FMOD_CHANNELGROUP *channelgroup, float directocclusion, float reverbocclusion);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_Get3DOcclusion)(FMOD_CHANNELGROUP *channelgroup, float *directocclusion, float *reverbocclusion);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetPaused)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetPaused)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *paused);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetMute)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL mute);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetMute)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *mute);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_Stop)(FMOD_CHANNELGROUP *channelgroup);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideVolume)(FMOD_CHANNELGROUP *channelgroup, float volume);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideFrequency)(FMOD_CHANNELGROUP *channelgroup, float frequency);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverridePan)(FMOD_CHANNELGROUP *channelgroup, float pan);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideReverbProperties)(FMOD_CHANNELGROUP *channelgroup, const FMOD_REVERB_CHANNELPROPERTIES *prop);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_Override3DAttributes)(FMOD_CHANNELGROUP *channelgroup, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideSpeakerMix)(FMOD_CHANNELGROUP *channelgroup, float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_AddGroup)(FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP *group);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetNumGroups)(FMOD_CHANNELGROUP *channelgroup, int *numgroups);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetGroup)(FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNELGROUP **group);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetParentGroup)(FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP **group);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetDSPHead)(FMOD_CHANNELGROUP *channelgroup, FMOD_DSP **dsp);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_AddDSP)(FMOD_CHANNELGROUP *channelgroup, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetName)(FMOD_CHANNELGROUP *channelgroup, char *name, int namelen);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetNumChannels)(FMOD_CHANNELGROUP *channelgroup, int *numchannels);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetChannel)(FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNEL **channel);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetSpectrum)(FMOD_CHANNELGROUP *channelgroup, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetWaveData)(FMOD_CHANNELGROUP *channelgroup, float *wavearray, int numvalues, int channeloffset);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetUserData)(FMOD_CHANNELGROUP *channelgroup, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetUserData)(FMOD_CHANNELGROUP *channelgroup, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetMemoryInfo)(FMOD_CHANNELGROUP *channelgroup, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_Release)(FMOD_SOUNDGROUP *soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetSystemObject)(FMOD_SOUNDGROUP *soundgroup, FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMaxAudible)(FMOD_SOUNDGROUP *soundgroup, int maxaudible);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMaxAudible)(FMOD_SOUNDGROUP *soundgroup, int *maxaudible);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMaxAudibleBehavior)(FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR behavior);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMaxAudibleBehavior)(FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR *behavior);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMuteFadeSpeed)(FMOD_SOUNDGROUP *soundgroup, float speed);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMuteFadeSpeed)(FMOD_SOUNDGROUP *soundgroup, float *speed);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_SetVolume)(FMOD_SOUNDGROUP *soundgroup, float volume);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetVolume)(FMOD_SOUNDGROUP *soundgroup, float *volume);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_Stop)(FMOD_SOUNDGROUP *soundgroup);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetName)(FMOD_SOUNDGROUP *soundgroup, char *name, int namelen);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetNumSounds)(FMOD_SOUNDGROUP *soundgroup, int *numsounds);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetSound)(FMOD_SOUNDGROUP *soundgroup, int index, FMOD_SOUND **sound);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetNumPlaying)(FMOD_SOUNDGROUP *soundgroup, int *numplaying);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_SetUserData)(FMOD_SOUNDGROUP *soundgroup, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetUserData)(FMOD_SOUNDGROUP *soundgroup, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMemoryInfo)(FMOD_SOUNDGROUP *soundgroup, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_DSP_Release)(FMOD_DSP *dsp);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetSystemObject)(FMOD_DSP *dsp, FMOD_SYSTEM **system);

 extern FMOD_RESULT (F_API *qFMOD_DSP_AddInput)(FMOD_DSP *dsp, FMOD_DSP *target, FMOD_DSPCONNECTION **connection);

 extern FMOD_RESULT (F_API *qFMOD_DSP_DisconnectFrom)(FMOD_DSP *dsp, FMOD_DSP *target);

 extern FMOD_RESULT (F_API *qFMOD_DSP_DisconnectAll)(FMOD_DSP *dsp, FMOD_BOOL inputs, FMOD_BOOL outputs);

 extern FMOD_RESULT (F_API *qFMOD_DSP_Remove)(FMOD_DSP *dsp);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetNumInputs)(FMOD_DSP *dsp, int *numinputs);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetNumOutputs)(FMOD_DSP *dsp, int *numoutputs);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetInput)(FMOD_DSP *dsp, int index, FMOD_DSP **input, FMOD_DSPCONNECTION **inputconnection);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetOutput)(FMOD_DSP *dsp, int index, FMOD_DSP **output, FMOD_DSPCONNECTION **outputconnection);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetActive)(FMOD_DSP *dsp, FMOD_BOOL active);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetActive)(FMOD_DSP *dsp, FMOD_BOOL *active);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetBypass)(FMOD_DSP *dsp, FMOD_BOOL bypass);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetBypass)(FMOD_DSP *dsp, FMOD_BOOL *bypass);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetSpeakerActive)(FMOD_DSP *dsp, FMOD_SPEAKER speaker, FMOD_BOOL active);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetSpeakerActive)(FMOD_DSP *dsp, FMOD_SPEAKER speaker, FMOD_BOOL *active);

 extern FMOD_RESULT (F_API *qFMOD_DSP_Reset)(FMOD_DSP *dsp);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetParameter)(FMOD_DSP *dsp, int index, float value);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetParameter)(FMOD_DSP *dsp, int index, float *value, char *valuestr, int valuestrlen);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetNumParameters)(FMOD_DSP *dsp, int *numparams);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetParameterInfo)(FMOD_DSP *dsp, int index, char *name, char *label, char *description, int descriptionlen, float *min, float *max);

 extern FMOD_RESULT (F_API *qFMOD_DSP_ShowConfigDialog)(FMOD_DSP *dsp, void *hwnd, FMOD_BOOL show);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetInfo)(FMOD_DSP *dsp, char *name, unsigned int *version, int *channels, int *configwidth, int *configheight);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetType)(FMOD_DSP *dsp, FMOD_DSP_TYPE *type);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetDefaults)(FMOD_DSP *dsp, float frequency, float volume, float pan, int priority);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetDefaults)(FMOD_DSP *dsp, float *frequency, float *volume, float *pan, int *priority);

 extern FMOD_RESULT (F_API *qFMOD_DSP_SetUserData)(FMOD_DSP *dsp, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetUserData)(FMOD_DSP *dsp, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_DSP_GetMemoryInfo)(FMOD_DSP *dsp, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetInput)(FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **input);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetOutput)(FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **output);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_SetMix)(FMOD_DSPCONNECTION *dspconnection, float volume);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetMix)(FMOD_DSPCONNECTION *dspconnection, float *volume);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_SetLevels)(FMOD_DSPCONNECTION *dspconnection, FMOD_SPEAKER speaker, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetLevels)(FMOD_DSPCONNECTION *dspconnection, FMOD_SPEAKER speaker, float *levels, int numlevels);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_SetUserData)(FMOD_DSPCONNECTION *dspconnection, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetUserData)(FMOD_DSPCONNECTION *dspconnection, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_DSPConnection_GetMemoryInfo)(FMOD_DSPCONNECTION *dspconnection, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_Release)(FMOD_GEOMETRY *geometry);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_AddPolygon)(FMOD_GEOMETRY *geometry, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided, int numvertices, const FMOD_VECTOR *vertices, int *polygonindex);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetNumPolygons)(FMOD_GEOMETRY *geometry, int *numpolygons);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetMaxPolygons)(FMOD_GEOMETRY *geometry, int *maxpolygons, int *maxvertices);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonNumVertices)(FMOD_GEOMETRY *geometry, int index, int *numvertices);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetPolygonVertex)(FMOD_GEOMETRY *geometry, int index, int vertexindex, const FMOD_VECTOR *vertex);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonVertex)(FMOD_GEOMETRY *geometry, int index, int vertexindex, FMOD_VECTOR *vertex);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetPolygonAttributes) (FMOD_GEOMETRY *geometry, int index, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonAttributes) (FMOD_GEOMETRY *geometry, int index, float *directocclusion, float *reverbocclusion, FMOD_BOOL *doublesided);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetActive)(FMOD_GEOMETRY *geometry, FMOD_BOOL active);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetActive)(FMOD_GEOMETRY *geometry, FMOD_BOOL *active);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetRotation)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *forward, const FMOD_VECTOR *up);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetRotation)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *forward, FMOD_VECTOR *up);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetPosition)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *position);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetPosition)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *position);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetScale)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *scale);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetScale)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *scale);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_Save)(FMOD_GEOMETRY *geometry, void *data, int *datasize);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_SetUserData)(FMOD_GEOMETRY *geometry, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetUserData)(FMOD_GEOMETRY *geometry, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_Geometry_GetMemoryInfo)(FMOD_GEOMETRY *geometry, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_Release)(FMOD_REVERB *reverb);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_Set3DAttributes)(FMOD_REVERB *reverb, const FMOD_VECTOR *position, float mindistance, float maxdistance);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_Get3DAttributes)(FMOD_REVERB *reverb, FMOD_VECTOR *position, float *mindistance, float *maxdistance);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_SetProperties)(FMOD_REVERB *reverb, const FMOD_REVERB_PROPERTIES *properties);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_GetProperties)(FMOD_REVERB *reverb, FMOD_REVERB_PROPERTIES *properties);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_SetActive)(FMOD_REVERB *reverb, FMOD_BOOL active);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_GetActive)(FMOD_REVERB *reverb, FMOD_BOOL *active);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_SetUserData)(FMOD_REVERB *reverb, void *userdata);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_GetUserData)(FMOD_REVERB *reverb, void **userdata);

 extern FMOD_RESULT (F_API *qFMOD_Reverb_GetMemoryInfo)(FMOD_REVERB *reverb, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);

 void QFMOD_Init(void);

 void QFMOD_Shutdown(void);

 #endif

 #include <metahook.h>

 #include "fmod.h"

 static HMODULE hFMOD = NULL;

 FMOD_RESULT (F_API *qFMOD_Memory_Initialize)(void *poolmem, int poollen, FMOD_MEMORY_ALLOCCALLBACK useralloc, FMOD_MEMORY_REALLOCCALLBACK userrealloc, FMOD_MEMORY_FREECALLBACK userfree, FMOD_MEMORY_TYPE memtypeflags) = ;

 FMOD_RESULT (F_API *qFMOD_Memory_GetStats)(int *currentalloced, int *maxalloced, FMOD_BOOL blocking) = ;

 FMOD_RESULT (F_API *qFMOD_Debug_SetLevel)(FMOD_DEBUGLEVEL level) = ;

 FMOD_RESULT (F_API *qFMOD_Debug_GetLevel)(FMOD_DEBUGLEVEL *level) = ;

 FMOD_RESULT (F_API *qFMOD_File_SetDiskBusy)(int busy) = ;

 FMOD_RESULT (F_API *qFMOD_File_GetDiskBusy)(int *busy) = ;

 FMOD_RESULT (F_API *qFMOD_System_Create)(FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_System_Release)(FMOD_SYSTEM *system) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetOutput)(FMOD_SYSTEM *system, FMOD_OUTPUTTYPE output) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetOutput)(FMOD_SYSTEM *system, FMOD_OUTPUTTYPE *output) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetNumDrivers)(FMOD_SYSTEM *system, int *numdrivers) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDriverInfo)(FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDriverInfoW)(FMOD_SYSTEM *system, int id, short *name, int namelen, FMOD_GUID *guid) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDriverCaps)(FMOD_SYSTEM *system, int id, FMOD_CAPS *caps, int *controlpaneloutputrate, FMOD_SPEAKERMODE *controlpanelspeakermode) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetDriver)(FMOD_SYSTEM *system, int driver) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDriver)(FMOD_SYSTEM *system, int *driver) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetHardwareChannels)(FMOD_SYSTEM *system, int numhardwarechannels) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetSoftwareChannels)(FMOD_SYSTEM *system, int numsoftwarechannels) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetSoftwareChannels)(FMOD_SYSTEM *system, int *numsoftwarechannels) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetSoftwareFormat)(FMOD_SYSTEM *system, int samplerate, FMOD_SOUND_FORMAT format, int numoutputchannels, int maxinputchannels, FMOD_DSP_RESAMPLER resamplemethod) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetSoftwareFormat)(FMOD_SYSTEM *system, int *samplerate, FMOD_SOUND_FORMAT *format, int *numoutputchannels, int *maxinputchannels, FMOD_DSP_RESAMPLER *resamplemethod, int *bits) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetDSPBufferSize)(FMOD_SYSTEM *system, unsigned int bufferlength, int numbuffers) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDSPBufferSize)(FMOD_SYSTEM *system, unsigned int *bufferlength, int *numbuffers) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetFileSystem)(FMOD_SYSTEM *system, FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek, FMOD_FILE_ASYNCREADCALLBACK userasyncread, FMOD_FILE_ASYNCCANCELCALLBACK userasynccancel, int blockalign) = ;

 FMOD_RESULT (F_API *qFMOD_System_AttachFileSystem)(FMOD_SYSTEM *system, FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetAdvancedSettings)(FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetAdvancedSettings)(FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetSpeakerMode)(FMOD_SYSTEM *system, FMOD_SPEAKERMODE speakermode) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetSpeakerMode)(FMOD_SYSTEM *system, FMOD_SPEAKERMODE *speakermode) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetCallback)(FMOD_SYSTEM *system, FMOD_SYSTEM_CALLBACK callback) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetPluginPath)(FMOD_SYSTEM *system, const char *path) = ;

 FMOD_RESULT (F_API *qFMOD_System_LoadPlugin)(FMOD_SYSTEM *system, const char *filename, unsigned int *handle, unsigned int priority) = ;

 FMOD_RESULT (F_API *qFMOD_System_UnloadPlugin)(FMOD_SYSTEM *system, unsigned int handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetNumPlugins)(FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int *numplugins) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetPluginHandle)(FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int index, unsigned int *handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetPluginInfo)(FMOD_SYSTEM *system, unsigned int handle, FMOD_PLUGINTYPE *plugintype, char *name, int namelen, unsigned int *version) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetOutputByPlugin)(FMOD_SYSTEM *system, unsigned int handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetOutputByPlugin)(FMOD_SYSTEM *system, unsigned int *handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateDSPByPlugin)(FMOD_SYSTEM *system, unsigned int handle, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_System_RegisterCodec)(FMOD_SYSTEM *system, FMOD_CODEC_DESCRIPTION *description, unsigned int *handle, unsigned int priority) = ;

 FMOD_RESULT (F_API *qFMOD_System_RegisterDSP)(FMOD_SYSTEM *system, FMOD_DSP_DESCRIPTION *description, unsigned int *handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_Init)(FMOD_SYSTEM *system, int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata) = ;

 FMOD_RESULT (F_API *qFMOD_System_Close)(FMOD_SYSTEM *system) = ;

 FMOD_RESULT (F_API *qFMOD_System_Update)(FMOD_SYSTEM *system) = ;

 FMOD_RESULT (F_API *qFMOD_System_Set3DSettings)(FMOD_SYSTEM *system, float dopplerscale, float distancefactor, float rolloffscale) = ;

 FMOD_RESULT (F_API *qFMOD_System_Get3DSettings)(FMOD_SYSTEM *system, float *dopplerscale, float *distancefactor, float *rolloffscale) = ;

 FMOD_RESULT (F_API *qFMOD_System_Set3DNumListeners)(FMOD_SYSTEM *system, int numlisteners) = ;

 FMOD_RESULT (F_API *qFMOD_System_Get3DNumListeners)(FMOD_SYSTEM *system, int *numlisteners) = ;

 FMOD_RESULT (F_API *qFMOD_System_Set3DListenerAttributes)(FMOD_SYSTEM *system, int listener, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel, const FMOD_VECTOR *forward, const FMOD_VECTOR *up) = ;

 FMOD_RESULT (F_API *qFMOD_System_Get3DListenerAttributes)(FMOD_SYSTEM *system, int listener, FMOD_VECTOR *pos, FMOD_VECTOR *vel, FMOD_VECTOR *forward, FMOD_VECTOR *up) = ;

 FMOD_RESULT (F_API *qFMOD_System_Set3DRolloffCallback)(FMOD_SYSTEM *system, FMOD_3D_ROLLOFFCALLBACK callback) = ;

 FMOD_RESULT (F_API *qFMOD_System_Set3DSpeakerPosition)(FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float x, float y, FMOD_BOOL active) = ;

 FMOD_RESULT (F_API *qFMOD_System_Get3DSpeakerPosition)(FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float *x, float *y, FMOD_BOOL *active) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetStreamBufferSize)(FMOD_SYSTEM *system, unsigned int filebuffersize, FMOD_TIMEUNIT filebuffersizetype) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetStreamBufferSize)(FMOD_SYSTEM *system, unsigned int *filebuffersize, FMOD_TIMEUNIT *filebuffersizetype) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetVersion)(FMOD_SYSTEM *system, unsigned int *version) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetOutputHandle)(FMOD_SYSTEM *system, void **handle) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetChannelsPlaying)(FMOD_SYSTEM *system, int *channels) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetHardwareChannels)(FMOD_SYSTEM *system, int *numhardwarechannels) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetCPUUsage)(FMOD_SYSTEM *system, float *dsp, float *stream, float *geometry, float *update, float *total) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetSoundRAM)(FMOD_SYSTEM *system, int *currentalloced, int *maxalloced, int *total) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetNumCDROMDrives)(FMOD_SYSTEM *system, int *numdrives) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetCDROMDriveName)(FMOD_SYSTEM *system, int drive, char *drivename, int drivenamelen, char *scsiname, int scsinamelen, char *devicename, int devicenamelen) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetSpectrum)(FMOD_SYSTEM *system, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetWaveData)(FMOD_SYSTEM *system, float *wavearray, int numvalues, int channeloffset) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateSound)(FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateStream)(FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateDSP)(FMOD_SYSTEM *system, FMOD_DSP_DESCRIPTION *description, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateDSPByType)(FMOD_SYSTEM *system, FMOD_DSP_TYPE type, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateChannelGroup)(FMOD_SYSTEM *system, const char *name, FMOD_CHANNELGROUP **channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateSoundGroup)(FMOD_SYSTEM *system, const char *name, FMOD_SOUNDGROUP **soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateReverb)(FMOD_SYSTEM *system, FMOD_REVERB **reverb) = ;

 FMOD_RESULT (F_API *qFMOD_System_PlaySound)(FMOD_SYSTEM *system, FMOD_CHANNELINDEX channelid, FMOD_SOUND *sound, FMOD_BOOL paused, FMOD_CHANNEL **channel) = ;

 FMOD_RESULT (F_API *qFMOD_System_PlayDSP)(FMOD_SYSTEM *system, FMOD_CHANNELINDEX channelid, FMOD_DSP *dsp, FMOD_BOOL paused, FMOD_CHANNEL **channel) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetChannel)(FMOD_SYSTEM *system, int channelid, FMOD_CHANNEL **channel) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetMasterChannelGroup)(FMOD_SYSTEM *system, FMOD_CHANNELGROUP **channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetMasterSoundGroup)(FMOD_SYSTEM *system, FMOD_SOUNDGROUP **soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetReverbProperties)(FMOD_SYSTEM *system, const FMOD_REVERB_PROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetReverbProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetReverbAmbientProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetReverbAmbientProperties)(FMOD_SYSTEM *system, FMOD_REVERB_PROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDSPHead)(FMOD_SYSTEM *system, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_System_AddDSP)(FMOD_SYSTEM *system, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection) = ;

 FMOD_RESULT (F_API *qFMOD_System_LockDSP)(FMOD_SYSTEM *system) = ;

 FMOD_RESULT (F_API *qFMOD_System_UnlockDSP)(FMOD_SYSTEM *system) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetDSPClock)(FMOD_SYSTEM *system, unsigned int *hi, unsigned int *lo) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetRecordNumDrivers)(FMOD_SYSTEM *system, int *numdrivers) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverInfo)(FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverInfoW)(FMOD_SYSTEM *system, int id, short *name, int namelen, FMOD_GUID *guid) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetRecordDriverCaps)(FMOD_SYSTEM *system, int id, FMOD_CAPS *caps, int *minfrequency, int *maxfrequency) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetRecordPosition)(FMOD_SYSTEM *system, int id, unsigned int *position) = ;

 FMOD_RESULT (F_API *qFMOD_System_RecordStart)(FMOD_SYSTEM *system, int id, FMOD_SOUND *sound, FMOD_BOOL loop) = ;

 FMOD_RESULT (F_API *qFMOD_System_RecordStop)(FMOD_SYSTEM *system, int id) = ;

 FMOD_RESULT (F_API *qFMOD_System_IsRecording)(FMOD_SYSTEM *system, int id, FMOD_BOOL *recording) = ;

 FMOD_RESULT (F_API *qFMOD_System_CreateGeometry)(FMOD_SYSTEM *system, int maxpolygons, int maxvertices, FMOD_GEOMETRY **geometry) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetGeometrySettings)(FMOD_SYSTEM *system, float maxworldsize) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetGeometrySettings)(FMOD_SYSTEM *system, float *maxworldsize) = ;

 FMOD_RESULT (F_API *qFMOD_System_LoadGeometry)(FMOD_SYSTEM *system, const void *data, int datasize, FMOD_GEOMETRY **geometry) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetGeometryOcclusion)(FMOD_SYSTEM *system, const FMOD_VECTOR *listener, const FMOD_VECTOR *source, float *direct, float *reverb) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetNetworkProxy)(FMOD_SYSTEM *system, const char *proxy) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetNetworkProxy)(FMOD_SYSTEM *system, char *proxy, int proxylen) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetNetworkTimeout)(FMOD_SYSTEM *system, int timeout) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetNetworkTimeout)(FMOD_SYSTEM *system, int *timeout) = ;

 FMOD_RESULT (F_API *qFMOD_System_SetUserData)(FMOD_SYSTEM *system, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetUserData)(FMOD_SYSTEM *system, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_System_GetMemoryInfo)(FMOD_SYSTEM *system, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Release)(FMOD_SOUND *sound) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSystemObject)(FMOD_SOUND *sound, FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Lock)(FMOD_SOUND *sound, unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Unlock)(FMOD_SOUND *sound, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetDefaults)(FMOD_SOUND *sound, float frequency, float volume, float pan, int priority) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetDefaults)(FMOD_SOUND *sound, float *frequency, float *volume, float *pan, int *priority) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetVariations)(FMOD_SOUND *sound, float frequencyvar, float volumevar, float panvar) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetVariations)(FMOD_SOUND *sound, float *frequencyvar, float *volumevar, float *panvar) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Set3DMinMaxDistance)(FMOD_SOUND *sound, float min, float max) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Get3DMinMaxDistance)(FMOD_SOUND *sound, float *min, float *max) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Set3DConeSettings)(FMOD_SOUND *sound, float insideconeangle, float outsideconeangle, float outsidevolume) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Get3DConeSettings)(FMOD_SOUND *sound, float *insideconeangle, float *outsideconeangle, float *outsidevolume) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Set3DCustomRolloff)(FMOD_SOUND *sound, FMOD_VECTOR *points, int numpoints) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_Get3DCustomRolloff)(FMOD_SOUND *sound, FMOD_VECTOR **points, int *numpoints) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetSubSound)(FMOD_SOUND *sound, int index, FMOD_SOUND *subsound) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSubSound)(FMOD_SOUND *sound, int index, FMOD_SOUND **subsound) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSubSoundParent)(FMOD_SOUND *sound, FMOD_SOUND **parentsound) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetSubSoundSentence)(FMOD_SOUND *sound, int *subsoundlist, int numsubsounds) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetName)(FMOD_SOUND *sound, char *name, int namelen) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetLength)(FMOD_SOUND *sound, unsigned int *length, FMOD_TIMEUNIT lengthtype) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetFormat)(FMOD_SOUND *sound, FMOD_SOUND_TYPE *type, FMOD_SOUND_FORMAT *format, int *channels, int *bits) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetNumSubSounds)(FMOD_SOUND *sound, int *numsubsounds) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetNumTags)(FMOD_SOUND *sound, int *numtags, int *numtagsupdated) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetTag)(FMOD_SOUND *sound, const char *name, int index, FMOD_TAG *tag) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetOpenState)(FMOD_SOUND *sound, FMOD_OPENSTATE *openstate, unsigned int *percentbuffered, FMOD_BOOL *starving, FMOD_BOOL *diskbusy) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_ReadData)(FMOD_SOUND *sound, void *buffer, unsigned int lenbytes, unsigned int *read) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SeekData)(FMOD_SOUND *sound, unsigned int pcm) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetSoundGroup)(FMOD_SOUND *sound, FMOD_SOUNDGROUP *soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSoundGroup)(FMOD_SOUND *sound, FMOD_SOUNDGROUP **soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetNumSyncPoints)(FMOD_SOUND *sound, int *numsyncpoints) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSyncPoint)(FMOD_SOUND *sound, int index, FMOD_SYNCPOINT **point) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetSyncPointInfo)(FMOD_SOUND *sound, FMOD_SYNCPOINT *point, char *name, int namelen, unsigned int *offset, FMOD_TIMEUNIT offsettype) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_AddSyncPoint)(FMOD_SOUND *sound, unsigned int offset, FMOD_TIMEUNIT offsettype, const char *name, FMOD_SYNCPOINT **point) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_DeleteSyncPoint)(FMOD_SOUND *sound, FMOD_SYNCPOINT *point) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetMode)(FMOD_SOUND *sound, FMOD_MODE mode) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetMode)(FMOD_SOUND *sound, FMOD_MODE *mode) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetLoopCount)(FMOD_SOUND *sound, int loopcount) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetLoopCount)(FMOD_SOUND *sound, int *loopcount) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetLoopPoints)(FMOD_SOUND *sound, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetLoopPoints)(FMOD_SOUND *sound, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetMusicNumChannels)(FMOD_SOUND *sound, int *numchannels) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetMusicChannelVolume)(FMOD_SOUND *sound, int channel, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetMusicChannelVolume)(FMOD_SOUND *sound, int channel, float *volume) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetMusicSpeed)(FMOD_SOUND *sound, float speed) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetMusicSpeed)(FMOD_SOUND *sound, float *speed) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_SetUserData)(FMOD_SOUND *sound, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetUserData)(FMOD_SOUND *sound, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Sound_GetMemoryInfo)(FMOD_SOUND *sound, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetSystemObject)(FMOD_CHANNEL *channel, FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Stop)(FMOD_CHANNEL *channel) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetPaused)(FMOD_CHANNEL *channel, FMOD_BOOL paused) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetPaused)(FMOD_CHANNEL *channel, FMOD_BOOL *paused) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetVolume)(FMOD_CHANNEL *channel, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetVolume)(FMOD_CHANNEL *channel, float *volume) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetFrequency)(FMOD_CHANNEL *channel, float frequency) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetFrequency)(FMOD_CHANNEL *channel, float *frequency) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetPan)(FMOD_CHANNEL *channel, float pan) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetPan)(FMOD_CHANNEL *channel, float *pan) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetDelay)(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int delayhi, unsigned int delaylo) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetDelay)(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int *delayhi, unsigned int *delaylo) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetSpeakerMix)(FMOD_CHANNEL *channel, float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetSpeakerMix)(FMOD_CHANNEL *channel, float *frontleft, float *frontright, float *center, float *lfe, float *backleft, float *backright, float *sideleft, float *sideright) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetSpeakerLevels)(FMOD_CHANNEL *channel, FMOD_SPEAKER speaker, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetSpeakerLevels)(FMOD_CHANNEL *channel, FMOD_SPEAKER speaker, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetInputChannelMix)(FMOD_CHANNEL *channel, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetInputChannelMix)(FMOD_CHANNEL *channel, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetMute)(FMOD_CHANNEL *channel, FMOD_BOOL mute) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetMute)(FMOD_CHANNEL *channel, FMOD_BOOL *mute) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetPriority)(FMOD_CHANNEL *channel, int priority) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetPriority)(FMOD_CHANNEL *channel, int *priority) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetPosition)(FMOD_CHANNEL *channel, unsigned int position, FMOD_TIMEUNIT postype) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetPosition)(FMOD_CHANNEL *channel, unsigned int *position, FMOD_TIMEUNIT postype) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetReverbProperties)(FMOD_CHANNEL *channel, const FMOD_REVERB_CHANNELPROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetReverbProperties)(FMOD_CHANNEL *channel, FMOD_REVERB_CHANNELPROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetLowPassGain)(FMOD_CHANNEL *channel, float gain) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetLowPassGain)(FMOD_CHANNEL *channel, float *gain) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetChannelGroup)(FMOD_CHANNEL *channel, FMOD_CHANNELGROUP *channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetChannelGroup)(FMOD_CHANNEL *channel, FMOD_CHANNELGROUP **channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetCallback)(FMOD_CHANNEL *channel, FMOD_CHANNEL_CALLBACK callback) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DAttributes)(FMOD_CHANNEL *channel, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DAttributes)(FMOD_CHANNEL *channel, FMOD_VECTOR *pos, FMOD_VECTOR *vel) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DMinMaxDistance)(FMOD_CHANNEL *channel, float mindistance, float maxdistance) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DMinMaxDistance)(FMOD_CHANNEL *channel, float *mindistance, float *maxdistance) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DConeSettings)(FMOD_CHANNEL *channel, float insideconeangle, float outsideconeangle, float outsidevolume) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DConeSettings)(FMOD_CHANNEL *channel, float *insideconeangle, float *outsideconeangle, float *outsidevolume) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DConeOrientation)(FMOD_CHANNEL *channel, FMOD_VECTOR *orientation) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DConeOrientation)(FMOD_CHANNEL *channel, FMOD_VECTOR *orientation) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DCustomRolloff)(FMOD_CHANNEL *channel, FMOD_VECTOR *points, int numpoints) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DCustomRolloff)(FMOD_CHANNEL *channel, FMOD_VECTOR **points, int *numpoints) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DOcclusion)(FMOD_CHANNEL *channel, float directocclusion, float reverbocclusion) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DOcclusion)(FMOD_CHANNEL *channel, float *directocclusion, float *reverbocclusion) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DSpread)(FMOD_CHANNEL *channel, float angle) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DSpread)(FMOD_CHANNEL *channel, float *angle) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DPanLevel)(FMOD_CHANNEL *channel, float level) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DPanLevel)(FMOD_CHANNEL *channel, float *level) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DDopplerLevel)(FMOD_CHANNEL *channel, float level) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DDopplerLevel)(FMOD_CHANNEL *channel, float *level) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Set3DDistanceFilter)(FMOD_CHANNEL *channel, FMOD_BOOL custom, float customLevel, float centerFreq) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_Get3DDistanceFilter)(FMOD_CHANNEL *channel, FMOD_BOOL *custom, float *customLevel, float *centerFreq) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetDSPHead)(FMOD_CHANNEL *channel, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_AddDSP)(FMOD_CHANNEL *channel, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_IsPlaying)(FMOD_CHANNEL *channel, FMOD_BOOL *isplaying) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_IsVirtual)(FMOD_CHANNEL *channel, FMOD_BOOL *isvirtual) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetAudibility)(FMOD_CHANNEL *channel, float *audibility) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetCurrentSound)(FMOD_CHANNEL *channel, FMOD_SOUND **sound) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetSpectrum)(FMOD_CHANNEL *channel, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetWaveData)(FMOD_CHANNEL *channel, float *wavearray, int numvalues, int channeloffset) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetIndex)(FMOD_CHANNEL *channel, int *index) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetMode)(FMOD_CHANNEL *channel, FMOD_MODE mode) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetMode)(FMOD_CHANNEL *channel, FMOD_MODE *mode) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetLoopCount)(FMOD_CHANNEL *channel, int loopcount) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetLoopCount)(FMOD_CHANNEL *channel, int *loopcount) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetLoopPoints)(FMOD_CHANNEL *channel, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetLoopPoints)(FMOD_CHANNEL *channel, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_SetUserData)(FMOD_CHANNEL *channel, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetUserData)(FMOD_CHANNEL *channel, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Channel_GetMemoryInfo)(FMOD_CHANNEL *channel, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_Release)(FMOD_CHANNELGROUP *channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetSystemObject)(FMOD_CHANNELGROUP *channelgroup, FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetVolume)(FMOD_CHANNELGROUP *channelgroup, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetVolume)(FMOD_CHANNELGROUP *channelgroup, float *volume) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetPitch)(FMOD_CHANNELGROUP *channelgroup, float pitch) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetPitch)(FMOD_CHANNELGROUP *channelgroup, float *pitch) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_Set3DOcclusion)(FMOD_CHANNELGROUP *channelgroup, float directocclusion, float reverbocclusion) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_Get3DOcclusion)(FMOD_CHANNELGROUP *channelgroup, float *directocclusion, float *reverbocclusion) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetPaused)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetPaused)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *paused) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetMute)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL mute) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetMute)(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *mute) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_Stop)(FMOD_CHANNELGROUP *channelgroup) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideVolume)(FMOD_CHANNELGROUP *channelgroup, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideFrequency)(FMOD_CHANNELGROUP *channelgroup, float frequency) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverridePan)(FMOD_CHANNELGROUP *channelgroup, float pan) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideReverbProperties)(FMOD_CHANNELGROUP *channelgroup, const FMOD_REVERB_CHANNELPROPERTIES *prop) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_Override3DAttributes)(FMOD_CHANNELGROUP *channelgroup, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_OverrideSpeakerMix)(FMOD_CHANNELGROUP *channelgroup, float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_AddGroup)(FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP *group) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetNumGroups)(FMOD_CHANNELGROUP *channelgroup, int *numgroups) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetGroup)(FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNELGROUP **group) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetParentGroup)(FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP **group) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetDSPHead)(FMOD_CHANNELGROUP *channelgroup, FMOD_DSP **dsp) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_AddDSP)(FMOD_CHANNELGROUP *channelgroup, FMOD_DSP *dsp, FMOD_DSPCONNECTION **connection) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetName)(FMOD_CHANNELGROUP *channelgroup, char *name, int namelen) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetNumChannels)(FMOD_CHANNELGROUP *channelgroup, int *numchannels) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetChannel)(FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNEL **channel) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetSpectrum)(FMOD_CHANNELGROUP *channelgroup, float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetWaveData)(FMOD_CHANNELGROUP *channelgroup, float *wavearray, int numvalues, int channeloffset) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_SetUserData)(FMOD_CHANNELGROUP *channelgroup, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetUserData)(FMOD_CHANNELGROUP *channelgroup, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_ChannelGroup_GetMemoryInfo)(FMOD_CHANNELGROUP *channelgroup, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_Release)(FMOD_SOUNDGROUP *soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetSystemObject)(FMOD_SOUNDGROUP *soundgroup, FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMaxAudible)(FMOD_SOUNDGROUP *soundgroup, int maxaudible) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMaxAudible)(FMOD_SOUNDGROUP *soundgroup, int *maxaudible) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMaxAudibleBehavior)(FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR behavior) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMaxAudibleBehavior)(FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR *behavior) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_SetMuteFadeSpeed)(FMOD_SOUNDGROUP *soundgroup, float speed) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMuteFadeSpeed)(FMOD_SOUNDGROUP *soundgroup, float *speed) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_SetVolume)(FMOD_SOUNDGROUP *soundgroup, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetVolume)(FMOD_SOUNDGROUP *soundgroup, float *volume) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_Stop)(FMOD_SOUNDGROUP *soundgroup) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetName)(FMOD_SOUNDGROUP *soundgroup, char *name, int namelen) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetNumSounds)(FMOD_SOUNDGROUP *soundgroup, int *numsounds) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetSound)(FMOD_SOUNDGROUP *soundgroup, int index, FMOD_SOUND **sound) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetNumPlaying)(FMOD_SOUNDGROUP *soundgroup, int *numplaying) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_SetUserData)(FMOD_SOUNDGROUP *soundgroup, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetUserData)(FMOD_SOUNDGROUP *soundgroup, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_SoundGroup_GetMemoryInfo)(FMOD_SOUNDGROUP *soundgroup, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_Release)(FMOD_DSP *dsp) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetSystemObject)(FMOD_DSP *dsp, FMOD_SYSTEM **system) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_AddInput)(FMOD_DSP *dsp, FMOD_DSP *target, FMOD_DSPCONNECTION **connection) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_DisconnectFrom)(FMOD_DSP *dsp, FMOD_DSP *target) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_DisconnectAll)(FMOD_DSP *dsp, FMOD_BOOL inputs, FMOD_BOOL outputs) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_Remove)(FMOD_DSP *dsp) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetNumInputs)(FMOD_DSP *dsp, int *numinputs) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetNumOutputs)(FMOD_DSP *dsp, int *numoutputs) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetInput)(FMOD_DSP *dsp, int index, FMOD_DSP **input, FMOD_DSPCONNECTION **inputconnection) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetOutput)(FMOD_DSP *dsp, int index, FMOD_DSP **output, FMOD_DSPCONNECTION **outputconnection) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetActive)(FMOD_DSP *dsp, FMOD_BOOL active) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetActive)(FMOD_DSP *dsp, FMOD_BOOL *active) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetBypass)(FMOD_DSP *dsp, FMOD_BOOL bypass) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetBypass)(FMOD_DSP *dsp, FMOD_BOOL *bypass) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetSpeakerActive)(FMOD_DSP *dsp, FMOD_SPEAKER speaker, FMOD_BOOL active) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetSpeakerActive)(FMOD_DSP *dsp, FMOD_SPEAKER speaker, FMOD_BOOL *active) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_Reset)(FMOD_DSP *dsp) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetParameter)(FMOD_DSP *dsp, int index, float value) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetParameter)(FMOD_DSP *dsp, int index, float *value, char *valuestr, int valuestrlen) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetNumParameters)(FMOD_DSP *dsp, int *numparams) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetParameterInfo)(FMOD_DSP *dsp, int index, char *name, char *label, char *description, int descriptionlen, float *min, float *max) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_ShowConfigDialog)(FMOD_DSP *dsp, void *hwnd, FMOD_BOOL show) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetInfo)(FMOD_DSP *dsp, char *name, unsigned int *version, int *channels, int *configwidth, int *configheight) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetType)(FMOD_DSP *dsp, FMOD_DSP_TYPE *type) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetDefaults)(FMOD_DSP *dsp, float frequency, float volume, float pan, int priority) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetDefaults)(FMOD_DSP *dsp, float *frequency, float *volume, float *pan, int *priority) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_SetUserData)(FMOD_DSP *dsp, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetUserData)(FMOD_DSP *dsp, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_DSP_GetMemoryInfo)(FMOD_DSP *dsp, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetInput)(FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **input) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetOutput)(FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **output) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_SetMix)(FMOD_DSPCONNECTION *dspconnection, float volume) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetMix)(FMOD_DSPCONNECTION *dspconnection, float *volume) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_SetLevels)(FMOD_DSPCONNECTION *dspconnection, FMOD_SPEAKER speaker, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetLevels)(FMOD_DSPCONNECTION *dspconnection, FMOD_SPEAKER speaker, float *levels, int numlevels) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_SetUserData)(FMOD_DSPCONNECTION *dspconnection, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetUserData)(FMOD_DSPCONNECTION *dspconnection, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_DSPConnection_GetMemoryInfo)(FMOD_DSPCONNECTION *dspconnection, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_Release)(FMOD_GEOMETRY *geometry) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_AddPolygon)(FMOD_GEOMETRY *geometry, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided, int numvertices, const FMOD_VECTOR *vertices, int *polygonindex) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetNumPolygons)(FMOD_GEOMETRY *geometry, int *numpolygons) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetMaxPolygons)(FMOD_GEOMETRY *geometry, int *maxpolygons, int *maxvertices) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonNumVertices)(FMOD_GEOMETRY *geometry, int index, int *numvertices) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetPolygonVertex)(FMOD_GEOMETRY *geometry, int index, int vertexindex, const FMOD_VECTOR *vertex) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonVertex)(FMOD_GEOMETRY *geometry, int index, int vertexindex, FMOD_VECTOR *vertex) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetPolygonAttributes) (FMOD_GEOMETRY *geometry, int index, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetPolygonAttributes) (FMOD_GEOMETRY *geometry, int index, float *directocclusion, float *reverbocclusion, FMOD_BOOL *doublesided) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetActive)(FMOD_GEOMETRY *geometry, FMOD_BOOL active) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetActive)(FMOD_GEOMETRY *geometry, FMOD_BOOL *active) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetRotation)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *forward, const FMOD_VECTOR *up) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetRotation)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *forward, FMOD_VECTOR *up) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetPosition)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *position) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetPosition)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *position) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetScale)(FMOD_GEOMETRY *geometry, const FMOD_VECTOR *scale) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetScale)(FMOD_GEOMETRY *geometry, FMOD_VECTOR *scale) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_Save)(FMOD_GEOMETRY *geometry, void *data, int *datasize) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_SetUserData)(FMOD_GEOMETRY *geometry, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetUserData)(FMOD_GEOMETRY *geometry, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Geometry_GetMemoryInfo)(FMOD_GEOMETRY *geometry, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_Release)(FMOD_REVERB *reverb) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_Set3DAttributes)(FMOD_REVERB *reverb, const FMOD_VECTOR *position, float mindistance, float maxdistance) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_Get3DAttributes)(FMOD_REVERB *reverb, FMOD_VECTOR *position, float *mindistance, float *maxdistance) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_SetProperties)(FMOD_REVERB *reverb, const FMOD_REVERB_PROPERTIES *properties) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_GetProperties)(FMOD_REVERB *reverb, FMOD_REVERB_PROPERTIES *properties) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_SetActive)(FMOD_REVERB *reverb, FMOD_BOOL active) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_GetActive)(FMOD_REVERB *reverb, FMOD_BOOL *active) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_SetUserData)(FMOD_REVERB *reverb, void *userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_GetUserData)(FMOD_REVERB *reverb, void **userdata) = ;

 FMOD_RESULT (F_API *qFMOD_Reverb_GetMemoryInfo)(FMOD_REVERB *reverb, unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details) = ;

 void QFMOD_Init(void)

 {

     hFMOD = LoadLibrary("fmodex.dll");

     if (hFMOD)

     {

         qFMOD_Memory_Initialize = (FMOD_RESULT (F_API *)(void *, int, FMOD_MEMORY_ALLOCCALLBACK, FMOD_MEMORY_REALLOCCALLBACK, FMOD_MEMORY_FREECALLBACK, FMOD_MEMORY_TYPE))GetProcAddress(hFMOD, "FMOD_Memory_Initialize");

         qFMOD_Memory_GetStats = (FMOD_RESULT (F_API *)(int *, int *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Memory_GetStats");

         qFMOD_Debug_SetLevel = (FMOD_RESULT (F_API *)(FMOD_DEBUGLEVEL))GetProcAddress(hFMOD, "FMOD_Debug_SetLevel");

         qFMOD_Debug_GetLevel = (FMOD_RESULT (F_API *)(FMOD_DEBUGLEVEL *))GetProcAddress(hFMOD, "FMOD_Debug_GetLevel");

         qFMOD_File_SetDiskBusy = (FMOD_RESULT (F_API *)(int))GetProcAddress(hFMOD, "FMOD_File_SetDiskBusy");

         qFMOD_File_GetDiskBusy = (FMOD_RESULT (F_API *)(int *))GetProcAddress(hFMOD, "FMOD_File_GetDiskBusy");

         qFMOD_System_Create = (FMOD_RESULT (F_API *)(FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_System_Create");

         qFMOD_System_Release = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *))GetProcAddress(hFMOD, "FMOD_System_Release");

         qFMOD_System_SetOutput = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_OUTPUTTYPE))GetProcAddress(hFMOD, "FMOD_System_SetOutput");

         qFMOD_System_GetOutput = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_OUTPUTTYPE *))GetProcAddress(hFMOD, "FMOD_System_GetOutput");

         qFMOD_System_GetNumDrivers = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetNumDrivers");

         qFMOD_System_GetDriverInfo = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, char *, int, FMOD_GUID *))GetProcAddress(hFMOD, "FMOD_System_GetDriverInfo");

         qFMOD_System_GetDriverInfoW = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, short *, int, FMOD_GUID *))GetProcAddress(hFMOD, "FMOD_System_GetDriverInfoW");

         qFMOD_System_GetDriverCaps = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_CAPS *, int *, FMOD_SPEAKERMODE *))GetProcAddress(hFMOD, "FMOD_System_GetDriverCaps");

         qFMOD_System_SetDriver = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_SetDriver");

         qFMOD_System_GetDriver = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetDriver");

         qFMOD_System_SetHardwareChannels = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_SetHardwareChannels");

         qFMOD_System_SetSoftwareChannels = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_SetSoftwareChannels");

         qFMOD_System_GetSoftwareChannels = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetSoftwareChannels");

         qFMOD_System_SetSoftwareFormat = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_SOUND_FORMAT, int, int, FMOD_DSP_RESAMPLER))GetProcAddress(hFMOD, "FMOD_System_SetSoftwareFormat");

         qFMOD_System_GetSoftwareFormat = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *, FMOD_SOUND_FORMAT *, int *, int *, FMOD_DSP_RESAMPLER *, int *))GetProcAddress(hFMOD, "FMOD_System_GetSoftwareFormat");

         qFMOD_System_SetDSPBufferSize = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int, int))GetProcAddress(hFMOD, "FMOD_System_SetDSPBufferSize");

         qFMOD_System_GetDSPBufferSize = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int *, int *))GetProcAddress(hFMOD, "FMOD_System_GetDSPBufferSize");

         qFMOD_System_SetFileSystem = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_FILE_OPENCALLBACK, FMOD_FILE_CLOSECALLBACK, FMOD_FILE_READCALLBACK, FMOD_FILE_SEEKCALLBACK, FMOD_FILE_ASYNCREADCALLBACK, FMOD_FILE_ASYNCCANCELCALLBACK, int))GetProcAddress(hFMOD, "FMOD_System_SetFileSystem");

         qFMOD_System_AttachFileSystem = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_FILE_OPENCALLBACK, FMOD_FILE_CLOSECALLBACK, FMOD_FILE_READCALLBACK, FMOD_FILE_SEEKCALLBACK))GetProcAddress(hFMOD, "FMOD_System_AttachFileSystem");

         qFMOD_System_SetAdvancedSettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_ADVANCEDSETTINGS *))GetProcAddress(hFMOD, "FMOD_System_SetAdvancedSettings");

         qFMOD_System_GetAdvancedSettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_ADVANCEDSETTINGS *))GetProcAddress(hFMOD, "FMOD_System_GetAdvancedSettings");

         qFMOD_System_SetSpeakerMode = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SPEAKERMODE))GetProcAddress(hFMOD, "FMOD_System_SetSpeakerMode");

         qFMOD_System_GetSpeakerMode = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SPEAKERMODE *))GetProcAddress(hFMOD, "FMOD_System_GetSpeakerMode");

         qFMOD_System_SetCallback = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SYSTEM_CALLBACK))GetProcAddress(hFMOD, "FMOD_System_SetCallback");

         qFMOD_System_SetPluginPath = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *))GetProcAddress(hFMOD, "FMOD_System_SetPluginPath");

         qFMOD_System_LoadPlugin = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *, unsigned int *, unsigned int))GetProcAddress(hFMOD, "FMOD_System_LoadPlugin");

         qFMOD_System_UnloadPlugin = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int))GetProcAddress(hFMOD, "FMOD_System_UnloadPlugin");

         qFMOD_System_GetNumPlugins = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_PLUGINTYPE, int *))GetProcAddress(hFMOD, "FMOD_System_GetNumPlugins");

         qFMOD_System_GetPluginHandle = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_PLUGINTYPE, int, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetPluginHandle");

         qFMOD_System_GetPluginInfo = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int, FMOD_PLUGINTYPE *, char *, int, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetPluginInfo");

         qFMOD_System_SetOutputByPlugin = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int))GetProcAddress(hFMOD, "FMOD_System_SetOutputByPlugin");

         qFMOD_System_GetOutputByPlugin = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetOutputByPlugin");

         qFMOD_System_CreateDSPByPlugin = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_System_CreateDSPByPlugin");

         qFMOD_System_RegisterCodec = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_CODEC_DESCRIPTION *, unsigned int *, unsigned int))GetProcAddress(hFMOD, "FMOD_System_RegisterCodec");

         qFMOD_System_RegisterDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_DSP_DESCRIPTION *, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_RegisterDSP");

         qFMOD_System_Init = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_INITFLAGS, void *))GetProcAddress(hFMOD, "FMOD_System_Init");

         qFMOD_System_Close = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *))GetProcAddress(hFMOD, "FMOD_System_Close");

         qFMOD_System_Update = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *))GetProcAddress(hFMOD, "FMOD_System_Update");

         qFMOD_System_Set3DSettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float, float, float))GetProcAddress(hFMOD, "FMOD_System_Set3DSettings");

         qFMOD_System_Get3DSettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_System_Get3DSettings");

         qFMOD_System_Set3DNumListeners = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_Set3DNumListeners");

         qFMOD_System_Get3DNumListeners = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_Get3DNumListeners");

         qFMOD_System_Set3DListenerAttributes = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, const FMOD_VECTOR *, const FMOD_VECTOR *, const FMOD_VECTOR *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_System_Set3DListenerAttributes");

         qFMOD_System_Get3DListenerAttributes = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_VECTOR *, FMOD_VECTOR *, FMOD_VECTOR *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_System_Get3DListenerAttributes");

         qFMOD_System_Set3DRolloffCallback = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_3D_ROLLOFFCALLBACK))GetProcAddress(hFMOD, "FMOD_System_Set3DRolloffCallback");

         qFMOD_System_Set3DSpeakerPosition = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SPEAKER, float, float, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_System_Set3DSpeakerPosition");

         qFMOD_System_Get3DSpeakerPosition = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SPEAKER, float *, float *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_System_Get3DSpeakerPosition");

         qFMOD_System_SetStreamBufferSize = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_System_SetStreamBufferSize");

         qFMOD_System_GetStreamBufferSize = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int *, FMOD_TIMEUNIT *))GetProcAddress(hFMOD, "FMOD_System_GetStreamBufferSize");

         qFMOD_System_GetVersion = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetVersion");

         qFMOD_System_GetOutputHandle = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, void **))GetProcAddress(hFMOD, "FMOD_System_GetOutputHandle");

         qFMOD_System_GetChannelsPlaying = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetChannelsPlaying");

         qFMOD_System_GetHardwareChannels = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetHardwareChannels");

         qFMOD_System_GetCPUUsage = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float *, float *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_System_GetCPUUsage");

         qFMOD_System_GetSoundRAM = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *, int *, int *))GetProcAddress(hFMOD, "FMOD_System_GetSoundRAM");

         qFMOD_System_GetNumCDROMDrives = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetNumCDROMDrives");

         qFMOD_System_GetCDROMDriveName = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, char *, int, char *, int, char *, int))GetProcAddress(hFMOD, "FMOD_System_GetCDROMDriveName");

         qFMOD_System_GetSpectrum = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float *, int, int, FMOD_DSP_FFT_WINDOW))GetProcAddress(hFMOD, "FMOD_System_GetSpectrum");

         qFMOD_System_GetWaveData = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float *, int, int))GetProcAddress(hFMOD, "FMOD_System_GetWaveData");

         qFMOD_System_CreateSound = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *, FMOD_MODE, FMOD_CREATESOUNDEXINFO *, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_System_CreateSound");

         qFMOD_System_CreateStream = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *, FMOD_MODE, FMOD_CREATESOUNDEXINFO *, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_System_CreateStream");

         qFMOD_System_CreateDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_DSP_DESCRIPTION *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_System_CreateDSP");

         qFMOD_System_CreateDSPByType = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_DSP_TYPE, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_System_CreateDSPByType");

         qFMOD_System_CreateChannelGroup = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *, FMOD_CHANNELGROUP **))GetProcAddress(hFMOD, "FMOD_System_CreateChannelGroup");

         qFMOD_System_CreateSoundGroup = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *, FMOD_SOUNDGROUP **))GetProcAddress(hFMOD, "FMOD_System_CreateSoundGroup");

         qFMOD_System_CreateReverb = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_REVERB **))GetProcAddress(hFMOD, "FMOD_System_CreateReverb");

         qFMOD_System_PlaySound = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_CHANNELINDEX, FMOD_SOUND *, FMOD_BOOL, FMOD_CHANNEL **))GetProcAddress(hFMOD, "FMOD_System_PlaySound");

         qFMOD_System_PlayDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_CHANNELINDEX, FMOD_DSP *, FMOD_BOOL, FMOD_CHANNEL **))GetProcAddress(hFMOD, "FMOD_System_PlayDSP");

         qFMOD_System_GetChannel = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_CHANNEL **))GetProcAddress(hFMOD, "FMOD_System_GetChannel");

         qFMOD_System_GetMasterChannelGroup = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_CHANNELGROUP **))GetProcAddress(hFMOD, "FMOD_System_GetMasterChannelGroup");

         qFMOD_System_GetMasterSoundGroup = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_SOUNDGROUP **))GetProcAddress(hFMOD, "FMOD_System_GetMasterSoundGroup");

         qFMOD_System_SetReverbProperties = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_System_SetReverbProperties");

         qFMOD_System_GetReverbProperties = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_System_GetReverbProperties");

         qFMOD_System_SetReverbAmbientProperties = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_System_SetReverbAmbientProperties");

         qFMOD_System_GetReverbAmbientProperties = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_System_GetReverbAmbientProperties");

         qFMOD_System_GetDSPHead = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_System_GetDSPHead");

         qFMOD_System_AddDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, FMOD_DSP *, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_System_AddDSP");

         qFMOD_System_LockDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *))GetProcAddress(hFMOD, "FMOD_System_LockDSP");

         qFMOD_System_UnlockDSP = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *))GetProcAddress(hFMOD, "FMOD_System_UnlockDSP");

         qFMOD_System_GetDSPClock = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int *, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetDSPClock");

         qFMOD_System_GetRecordNumDrivers = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetRecordNumDrivers");

         qFMOD_System_GetRecordDriverInfo = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, char *, int, FMOD_GUID *))GetProcAddress(hFMOD, "FMOD_System_GetRecordDriverInfo");

         qFMOD_System_GetRecordDriverInfoW = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, short *, int, FMOD_GUID *))GetProcAddress(hFMOD, "FMOD_System_GetRecordDriverInfoW");

         qFMOD_System_GetRecordDriverCaps = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_CAPS *, int *, int *))GetProcAddress(hFMOD, "FMOD_System_GetRecordDriverCaps");

         qFMOD_System_GetRecordPosition = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, unsigned int *))GetProcAddress(hFMOD, "FMOD_System_GetRecordPosition");

         qFMOD_System_RecordStart = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_SOUND *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_System_RecordStart");

         qFMOD_System_RecordStop = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_RecordStop");

         qFMOD_System_IsRecording = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_System_IsRecording");

         qFMOD_System_CreateGeometry = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int, int, FMOD_GEOMETRY **))GetProcAddress(hFMOD, "FMOD_System_CreateGeometry");

         qFMOD_System_SetGeometrySettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float))GetProcAddress(hFMOD, "FMOD_System_SetGeometrySettings");

         qFMOD_System_GetGeometrySettings = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, float *))GetProcAddress(hFMOD, "FMOD_System_GetGeometrySettings");

         qFMOD_System_LoadGeometry = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const void *, int, FMOD_GEOMETRY **))GetProcAddress(hFMOD, "FMOD_System_LoadGeometry");

         qFMOD_System_GetGeometryOcclusion = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const FMOD_VECTOR *, const FMOD_VECTOR *, float *, float *))GetProcAddress(hFMOD, "FMOD_System_GetGeometryOcclusion");

         qFMOD_System_SetNetworkProxy = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, const char *))GetProcAddress(hFMOD, "FMOD_System_SetNetworkProxy");

         qFMOD_System_GetNetworkProxy = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, char *, int))GetProcAddress(hFMOD, "FMOD_System_GetNetworkProxy");

         qFMOD_System_SetNetworkTimeout = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int))GetProcAddress(hFMOD, "FMOD_System_SetNetworkTimeout");

         qFMOD_System_GetNetworkTimeout = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, int *))GetProcAddress(hFMOD, "FMOD_System_GetNetworkTimeout");

         qFMOD_System_SetUserData = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, void *))GetProcAddress(hFMOD, "FMOD_System_SetUserData");

         qFMOD_System_GetUserData = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, void **))GetProcAddress(hFMOD, "FMOD_System_GetUserData");

         qFMOD_System_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_SYSTEM *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_System_GetMemoryInfo");

         qFMOD_Sound_Release = (FMOD_RESULT (F_API *)(FMOD_SOUND *))GetProcAddress(hFMOD, "FMOD_Sound_Release");

         qFMOD_Sound_GetSystemObject = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_Sound_GetSystemObject");

         qFMOD_Sound_Lock = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int, unsigned int, void **, void **, unsigned int *, unsigned int *))GetProcAddress(hFMOD, "FMOD_Sound_Lock");

         qFMOD_Sound_Unlock = (FMOD_RESULT (F_API *)(FMOD_SOUND *, void *, void *, unsigned int, unsigned int))GetProcAddress(hFMOD, "FMOD_Sound_Unlock");

         qFMOD_Sound_SetDefaults = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float, float, float, int))GetProcAddress(hFMOD, "FMOD_Sound_SetDefaults");

         qFMOD_Sound_GetDefaults = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float *, float *, float *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetDefaults");

         qFMOD_Sound_SetVariations = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float, float, float))GetProcAddress(hFMOD, "FMOD_Sound_SetVariations");

         qFMOD_Sound_GetVariations = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_Sound_GetVariations");

         qFMOD_Sound_Set3DMinMaxDistance = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float, float))GetProcAddress(hFMOD, "FMOD_Sound_Set3DMinMaxDistance");

         qFMOD_Sound_Get3DMinMaxDistance = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float *, float *))GetProcAddress(hFMOD, "FMOD_Sound_Get3DMinMaxDistance");

         qFMOD_Sound_Set3DConeSettings = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float, float, float))GetProcAddress(hFMOD, "FMOD_Sound_Set3DConeSettings");

         qFMOD_Sound_Get3DConeSettings = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_Sound_Get3DConeSettings");

         qFMOD_Sound_Set3DCustomRolloff = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_VECTOR *, int))GetProcAddress(hFMOD, "FMOD_Sound_Set3DCustomRolloff");

         qFMOD_Sound_Get3DCustomRolloff = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_VECTOR **, int *))GetProcAddress(hFMOD, "FMOD_Sound_Get3DCustomRolloff");

         qFMOD_Sound_SetSubSound = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int, FMOD_SOUND *))GetProcAddress(hFMOD, "FMOD_Sound_SetSubSound");

         qFMOD_Sound_GetSubSound = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_Sound_GetSubSound");

         qFMOD_Sound_GetSubSoundParent = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_Sound_GetSubSoundParent");

         qFMOD_Sound_SetSubSoundSentence = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *, int))GetProcAddress(hFMOD, "FMOD_Sound_SetSubSoundSentence");

         qFMOD_Sound_GetName = (FMOD_RESULT (F_API *)(FMOD_SOUND *, char *, int))GetProcAddress(hFMOD, "FMOD_Sound_GetName");

         qFMOD_Sound_GetLength = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int *, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Sound_GetLength");

         qFMOD_Sound_GetFormat = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SOUND_TYPE *, FMOD_SOUND_FORMAT *, int *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetFormat");

         qFMOD_Sound_GetNumSubSounds = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetNumSubSounds");

         qFMOD_Sound_GetNumTags = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetNumTags");

         qFMOD_Sound_GetTag = (FMOD_RESULT (F_API *)(FMOD_SOUND *, const char *, int, FMOD_TAG *))GetProcAddress(hFMOD, "FMOD_Sound_GetTag");

         qFMOD_Sound_GetOpenState = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_OPENSTATE *, unsigned int *, FMOD_BOOL *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Sound_GetOpenState");

         qFMOD_Sound_ReadData = (FMOD_RESULT (F_API *)(FMOD_SOUND *, void *, unsigned int, unsigned int *))GetProcAddress(hFMOD, "FMOD_Sound_ReadData");

         qFMOD_Sound_SeekData = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int))GetProcAddress(hFMOD, "FMOD_Sound_SeekData");

         qFMOD_Sound_SetSoundGroup = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SOUNDGROUP *))GetProcAddress(hFMOD, "FMOD_Sound_SetSoundGroup");

         qFMOD_Sound_GetSoundGroup = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SOUNDGROUP **))GetProcAddress(hFMOD, "FMOD_Sound_GetSoundGroup");

         qFMOD_Sound_GetNumSyncPoints = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetNumSyncPoints");

         qFMOD_Sound_GetSyncPoint = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int, FMOD_SYNCPOINT **))GetProcAddress(hFMOD, "FMOD_Sound_GetSyncPoint");

         qFMOD_Sound_GetSyncPointInfo = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SYNCPOINT *, char *, int, unsigned int *, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Sound_GetSyncPointInfo");

         qFMOD_Sound_AddSyncPoint = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int, FMOD_TIMEUNIT, const char *, FMOD_SYNCPOINT **))GetProcAddress(hFMOD, "FMOD_Sound_AddSyncPoint");

         qFMOD_Sound_DeleteSyncPoint = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_SYNCPOINT *))GetProcAddress(hFMOD, "FMOD_Sound_DeleteSyncPoint");

         qFMOD_Sound_SetMode = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_MODE))GetProcAddress(hFMOD, "FMOD_Sound_SetMode");

         qFMOD_Sound_GetMode = (FMOD_RESULT (F_API *)(FMOD_SOUND *, FMOD_MODE *))GetProcAddress(hFMOD, "FMOD_Sound_GetMode");

         qFMOD_Sound_SetLoopCount = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int))GetProcAddress(hFMOD, "FMOD_Sound_SetLoopCount");

         qFMOD_Sound_GetLoopCount = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetLoopCount");

         qFMOD_Sound_SetLoopPoints = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int, FMOD_TIMEUNIT, unsigned int, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Sound_SetLoopPoints");

         qFMOD_Sound_GetLoopPoints = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int *, FMOD_TIMEUNIT, unsigned int *, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Sound_GetLoopPoints");

         qFMOD_Sound_GetMusicNumChannels = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int *))GetProcAddress(hFMOD, "FMOD_Sound_GetMusicNumChannels");

         qFMOD_Sound_SetMusicChannelVolume = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int, float))GetProcAddress(hFMOD, "FMOD_Sound_SetMusicChannelVolume");

         qFMOD_Sound_GetMusicChannelVolume = (FMOD_RESULT (F_API *)(FMOD_SOUND *, int, float *))GetProcAddress(hFMOD, "FMOD_Sound_GetMusicChannelVolume");

         qFMOD_Sound_SetMusicSpeed = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float))GetProcAddress(hFMOD, "FMOD_Sound_SetMusicSpeed");

         qFMOD_Sound_GetMusicSpeed = (FMOD_RESULT (F_API *)(FMOD_SOUND *, float *))GetProcAddress(hFMOD, "FMOD_Sound_GetMusicSpeed");

         qFMOD_Sound_SetUserData = (FMOD_RESULT (F_API *)(FMOD_SOUND *, void *))GetProcAddress(hFMOD, "FMOD_Sound_SetUserData");

         qFMOD_Sound_GetUserData = (FMOD_RESULT (F_API *)(FMOD_SOUND *, void **))GetProcAddress(hFMOD, "FMOD_Sound_GetUserData");

         qFMOD_Sound_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_SOUND *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_Sound_GetMemoryInfo");

         qFMOD_Channel_GetSystemObject = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_Channel_GetSystemObject");

         qFMOD_Channel_Stop = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *))GetProcAddress(hFMOD, "FMOD_Channel_Stop");

         qFMOD_Channel_SetPaused = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Channel_SetPaused");

         qFMOD_Channel_GetPaused = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Channel_GetPaused");

         qFMOD_Channel_SetVolume = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_SetVolume");

         qFMOD_Channel_GetVolume = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetVolume");

         qFMOD_Channel_SetFrequency = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_SetFrequency");

         qFMOD_Channel_GetFrequency = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetFrequency");

         qFMOD_Channel_SetPan = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_SetPan");

         qFMOD_Channel_GetPan = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetPan");

         qFMOD_Channel_SetDelay = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_DELAYTYPE, unsigned int, unsigned int))GetProcAddress(hFMOD, "FMOD_Channel_SetDelay");

         qFMOD_Channel_GetDelay = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_DELAYTYPE, unsigned int *, unsigned int *))GetProcAddress(hFMOD, "FMOD_Channel_GetDelay");

         qFMOD_Channel_SetSpeakerMix = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float, float, float, float, float, float, float, float))GetProcAddress(hFMOD, "FMOD_Channel_SetSpeakerMix");

         qFMOD_Channel_GetSpeakerMix = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, float *, float *, float *, float *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetSpeakerMix");

         qFMOD_Channel_SetSpeakerLevels = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_SPEAKER, float *, int))GetProcAddress(hFMOD, "FMOD_Channel_SetSpeakerLevels");

         qFMOD_Channel_GetSpeakerLevels = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_SPEAKER, float *, int))GetProcAddress(hFMOD, "FMOD_Channel_GetSpeakerLevels");

         qFMOD_Channel_SetInputChannelMix = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, int))GetProcAddress(hFMOD, "FMOD_Channel_SetInputChannelMix");

         qFMOD_Channel_GetInputChannelMix = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, int))GetProcAddress(hFMOD, "FMOD_Channel_GetInputChannelMix");

         qFMOD_Channel_SetMute = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Channel_SetMute");

         qFMOD_Channel_GetMute = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Channel_GetMute");

         qFMOD_Channel_SetPriority = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, int))GetProcAddress(hFMOD, "FMOD_Channel_SetPriority");

         qFMOD_Channel_GetPriority = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, int *))GetProcAddress(hFMOD, "FMOD_Channel_GetPriority");

         qFMOD_Channel_SetPosition = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, unsigned int, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Channel_SetPosition");

         qFMOD_Channel_GetPosition = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, unsigned int *, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Channel_GetPosition");

         qFMOD_Channel_SetReverbProperties = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, const FMOD_REVERB_CHANNELPROPERTIES *))GetProcAddress(hFMOD, "FMOD_Channel_SetReverbProperties");

         qFMOD_Channel_GetReverbProperties = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_REVERB_CHANNELPROPERTIES *))GetProcAddress(hFMOD, "FMOD_Channel_GetReverbProperties");

         qFMOD_Channel_SetLowPassGain = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_SetLowPassGain");

         qFMOD_Channel_GetLowPassGain = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetLowPassGain");

         qFMOD_Channel_SetChannelGroup = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_CHANNELGROUP *))GetProcAddress(hFMOD, "FMOD_Channel_SetChannelGroup");

         qFMOD_Channel_GetChannelGroup = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_CHANNELGROUP **))GetProcAddress(hFMOD, "FMOD_Channel_GetChannelGroup");

         qFMOD_Channel_SetCallback = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_CHANNEL_CALLBACK))GetProcAddress(hFMOD, "FMOD_Channel_SetCallback");

         qFMOD_Channel_Set3DAttributes = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, const FMOD_VECTOR *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Channel_Set3DAttributes");

         qFMOD_Channel_Get3DAttributes = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_VECTOR *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DAttributes");

         qFMOD_Channel_Set3DMinMaxDistance = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DMinMaxDistance");

         qFMOD_Channel_Get3DMinMaxDistance = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DMinMaxDistance");

         qFMOD_Channel_Set3DConeSettings = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float, float, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DConeSettings");

         qFMOD_Channel_Get3DConeSettings = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, float *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DConeSettings");

         qFMOD_Channel_Set3DConeOrientation = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Channel_Set3DConeOrientation");

         qFMOD_Channel_Get3DConeOrientation = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DConeOrientation");

         qFMOD_Channel_Set3DCustomRolloff = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_VECTOR *, int))GetProcAddress(hFMOD, "FMOD_Channel_Set3DCustomRolloff");

         qFMOD_Channel_Get3DCustomRolloff = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_VECTOR **, int *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DCustomRolloff");

         qFMOD_Channel_Set3DOcclusion = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DOcclusion");

         qFMOD_Channel_Get3DOcclusion = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DOcclusion");

         qFMOD_Channel_Set3DSpread = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DSpread");

         qFMOD_Channel_Get3DSpread = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DSpread");

         qFMOD_Channel_Set3DPanLevel = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DPanLevel");

         qFMOD_Channel_Get3DPanLevel = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DPanLevel");

         qFMOD_Channel_Set3DDopplerLevel = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DDopplerLevel");

         qFMOD_Channel_Get3DDopplerLevel = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DDopplerLevel");

         qFMOD_Channel_Set3DDistanceFilter = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL, float, float))GetProcAddress(hFMOD, "FMOD_Channel_Set3DDistanceFilter");

         qFMOD_Channel_Get3DDistanceFilter = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL *, float *, float *))GetProcAddress(hFMOD, "FMOD_Channel_Get3DDistanceFilter");

         qFMOD_Channel_GetDSPHead = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_Channel_GetDSPHead");

         qFMOD_Channel_AddDSP = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_DSP *, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_Channel_AddDSP");

         qFMOD_Channel_IsPlaying = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Channel_IsPlaying");

         qFMOD_Channel_IsVirtual = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Channel_IsVirtual");

         qFMOD_Channel_GetAudibility = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *))GetProcAddress(hFMOD, "FMOD_Channel_GetAudibility");

         qFMOD_Channel_GetCurrentSound = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_Channel_GetCurrentSound");

         qFMOD_Channel_GetSpectrum = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, int, int, FMOD_DSP_FFT_WINDOW))GetProcAddress(hFMOD, "FMOD_Channel_GetSpectrum");

         qFMOD_Channel_GetWaveData = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, float *, int, int))GetProcAddress(hFMOD, "FMOD_Channel_GetWaveData");

         qFMOD_Channel_GetIndex = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, int *))GetProcAddress(hFMOD, "FMOD_Channel_GetIndex");

         qFMOD_Channel_SetMode = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_MODE))GetProcAddress(hFMOD, "FMOD_Channel_SetMode");

         qFMOD_Channel_GetMode = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, FMOD_MODE *))GetProcAddress(hFMOD, "FMOD_Channel_GetMode");

         qFMOD_Channel_SetLoopCount = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, int))GetProcAddress(hFMOD, "FMOD_Channel_SetLoopCount");

         qFMOD_Channel_GetLoopCount = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, int *))GetProcAddress(hFMOD, "FMOD_Channel_GetLoopCount");

         qFMOD_Channel_SetLoopPoints = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, unsigned int, FMOD_TIMEUNIT, unsigned int, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Channel_SetLoopPoints");

         qFMOD_Channel_GetLoopPoints = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, unsigned int *, FMOD_TIMEUNIT, unsigned int *, FMOD_TIMEUNIT))GetProcAddress(hFMOD, "FMOD_Channel_GetLoopPoints");

         qFMOD_Channel_SetUserData = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, void *))GetProcAddress(hFMOD, "FMOD_Channel_SetUserData");

         qFMOD_Channel_GetUserData = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, void **))GetProcAddress(hFMOD, "FMOD_Channel_GetUserData");

         qFMOD_Channel_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_CHANNEL *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_Channel_GetMemoryInfo");

         qFMOD_ChannelGroup_Release = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_Release");

         qFMOD_ChannelGroup_GetSystemObject = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetSystemObject");

         qFMOD_ChannelGroup_SetVolume = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_SetVolume");

         qFMOD_ChannelGroup_GetVolume = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetVolume");

         qFMOD_ChannelGroup_SetPitch = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_SetPitch");

         qFMOD_ChannelGroup_GetPitch = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetPitch");

         qFMOD_ChannelGroup_Set3DOcclusion = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_Set3DOcclusion");

         qFMOD_ChannelGroup_Get3DOcclusion = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float *, float *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_Get3DOcclusion");

         qFMOD_ChannelGroup_SetPaused = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_ChannelGroup_SetPaused");

         qFMOD_ChannelGroup_GetPaused = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetPaused");

         qFMOD_ChannelGroup_SetMute = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_ChannelGroup_SetMute");

         qFMOD_ChannelGroup_GetMute = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetMute");

         qFMOD_ChannelGroup_Stop = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_Stop");

         qFMOD_ChannelGroup_OverrideVolume = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_OverrideVolume");

         qFMOD_ChannelGroup_OverrideFrequency = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_OverrideFrequency");

         qFMOD_ChannelGroup_OverridePan = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_OverridePan");

         qFMOD_ChannelGroup_OverrideReverbProperties = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, const FMOD_REVERB_CHANNELPROPERTIES *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_OverrideReverbProperties");

         qFMOD_ChannelGroup_Override3DAttributes = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, const FMOD_VECTOR *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_Override3DAttributes");

         qFMOD_ChannelGroup_OverrideSpeakerMix = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float, float, float, float, float, float, float, float))GetProcAddress(hFMOD, "FMOD_ChannelGroup_OverrideSpeakerMix");

         qFMOD_ChannelGroup_AddGroup = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_CHANNELGROUP *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_AddGroup");

         qFMOD_ChannelGroup_GetNumGroups = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, int *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetNumGroups");

         qFMOD_ChannelGroup_GetGroup = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, int, FMOD_CHANNELGROUP **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetGroup");

         qFMOD_ChannelGroup_GetParentGroup = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_CHANNELGROUP **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetParentGroup");

         qFMOD_ChannelGroup_GetDSPHead = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetDSPHead");

         qFMOD_ChannelGroup_AddDSP = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, FMOD_DSP *, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_AddDSP");

         qFMOD_ChannelGroup_GetName = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, char *, int))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetName");

         qFMOD_ChannelGroup_GetNumChannels = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, int *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetNumChannels");

         qFMOD_ChannelGroup_GetChannel = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, int, FMOD_CHANNEL **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetChannel");

         qFMOD_ChannelGroup_GetSpectrum = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float *, int, int, FMOD_DSP_FFT_WINDOW))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetSpectrum");

         qFMOD_ChannelGroup_GetWaveData = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, float *, int, int))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetWaveData");

         qFMOD_ChannelGroup_SetUserData = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, void *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_SetUserData");

         qFMOD_ChannelGroup_GetUserData = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, void **))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetUserData");

         qFMOD_ChannelGroup_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_CHANNELGROUP *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_ChannelGroup_GetMemoryInfo");

         qFMOD_SoundGroup_Release = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *))GetProcAddress(hFMOD, "FMOD_SoundGroup_Release");

         qFMOD_SoundGroup_GetSystemObject = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetSystemObject");

         qFMOD_SoundGroup_SetMaxAudible = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, int))GetProcAddress(hFMOD, "FMOD_SoundGroup_SetMaxAudible");

         qFMOD_SoundGroup_GetMaxAudible = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, int *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetMaxAudible");

         qFMOD_SoundGroup_SetMaxAudibleBehavior = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, FMOD_SOUNDGROUP_BEHAVIOR))GetProcAddress(hFMOD, "FMOD_SoundGroup_SetMaxAudibleBehavior");

         qFMOD_SoundGroup_GetMaxAudibleBehavior = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, FMOD_SOUNDGROUP_BEHAVIOR *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetMaxAudibleBehavior");

         qFMOD_SoundGroup_SetMuteFadeSpeed = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, float))GetProcAddress(hFMOD, "FMOD_SoundGroup_SetMuteFadeSpeed");

         qFMOD_SoundGroup_GetMuteFadeSpeed = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, float *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetMuteFadeSpeed");

         qFMOD_SoundGroup_SetVolume = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, float))GetProcAddress(hFMOD, "FMOD_SoundGroup_SetVolume");

         qFMOD_SoundGroup_GetVolume = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, float *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetVolume");

         qFMOD_SoundGroup_Stop = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *))GetProcAddress(hFMOD, "FMOD_SoundGroup_Stop");

         qFMOD_SoundGroup_GetName = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, char *, int))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetName");

         qFMOD_SoundGroup_GetNumSounds = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, int *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetNumSounds");

         qFMOD_SoundGroup_GetSound = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, int, FMOD_SOUND **))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetSound");

         qFMOD_SoundGroup_GetNumPlaying = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, int *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetNumPlaying");

         qFMOD_SoundGroup_SetUserData = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, void *))GetProcAddress(hFMOD, "FMOD_SoundGroup_SetUserData");

         qFMOD_SoundGroup_GetUserData = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, void **))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetUserData");

         qFMOD_SoundGroup_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_SOUNDGROUP *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_SoundGroup_GetMemoryInfo");

         qFMOD_DSP_Release = (FMOD_RESULT (F_API *)(FMOD_DSP *))GetProcAddress(hFMOD, "FMOD_DSP_Release");

         qFMOD_DSP_GetSystemObject = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_SYSTEM **))GetProcAddress(hFMOD, "FMOD_DSP_GetSystemObject");

         qFMOD_DSP_AddInput = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_DSP *, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_DSP_AddInput");

         qFMOD_DSP_DisconnectFrom = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_DSP *))GetProcAddress(hFMOD, "FMOD_DSP_DisconnectFrom");

         qFMOD_DSP_DisconnectAll = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_BOOL, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_DSP_DisconnectAll");

         qFMOD_DSP_Remove = (FMOD_RESULT (F_API *)(FMOD_DSP *))GetProcAddress(hFMOD, "FMOD_DSP_Remove");

         qFMOD_DSP_GetNumInputs = (FMOD_RESULT (F_API *)(FMOD_DSP *, int *))GetProcAddress(hFMOD, "FMOD_DSP_GetNumInputs");

         qFMOD_DSP_GetNumOutputs = (FMOD_RESULT (F_API *)(FMOD_DSP *, int *))GetProcAddress(hFMOD, "FMOD_DSP_GetNumOutputs");

         qFMOD_DSP_GetInput = (FMOD_RESULT (F_API *)(FMOD_DSP *, int, FMOD_DSP **, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_DSP_GetInput");

         qFMOD_DSP_GetOutput = (FMOD_RESULT (F_API *)(FMOD_DSP *, int, FMOD_DSP **, FMOD_DSPCONNECTION **))GetProcAddress(hFMOD, "FMOD_DSP_GetOutput");

         qFMOD_DSP_SetActive = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_DSP_SetActive");

         qFMOD_DSP_GetActive = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_DSP_GetActive");

         qFMOD_DSP_SetBypass = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_DSP_SetBypass");

         qFMOD_DSP_GetBypass = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_DSP_GetBypass");

         qFMOD_DSP_SetSpeakerActive = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_SPEAKER, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_DSP_SetSpeakerActive");

         qFMOD_DSP_GetSpeakerActive = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_SPEAKER, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_DSP_GetSpeakerActive");

         qFMOD_DSP_Reset = (FMOD_RESULT (F_API *)(FMOD_DSP *))GetProcAddress(hFMOD, "FMOD_DSP_Reset");

         qFMOD_DSP_SetParameter = (FMOD_RESULT (F_API *)(FMOD_DSP *, int, float))GetProcAddress(hFMOD, "FMOD_DSP_SetParameter");

         qFMOD_DSP_GetParameter = (FMOD_RESULT (F_API *)(FMOD_DSP *, int, float *, char *, int))GetProcAddress(hFMOD, "FMOD_DSP_GetParameter");

         qFMOD_DSP_GetNumParameters = (FMOD_RESULT (F_API *)(FMOD_DSP *, int *))GetProcAddress(hFMOD, "FMOD_DSP_GetNumParameters");

         qFMOD_DSP_GetParameterInfo = (FMOD_RESULT (F_API *)(FMOD_DSP *, int, char *, char *, char *, int, float *, float *))GetProcAddress(hFMOD, "FMOD_DSP_GetParameterInfo");

         qFMOD_DSP_ShowConfigDialog = (FMOD_RESULT (F_API *)(FMOD_DSP *, void *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_DSP_ShowConfigDialog");

         qFMOD_DSP_GetInfo = (FMOD_RESULT (F_API *)(FMOD_DSP *, char *, unsigned int *, int *, int *, int *))GetProcAddress(hFMOD, "FMOD_DSP_GetInfo");

         qFMOD_DSP_GetType = (FMOD_RESULT (F_API *)(FMOD_DSP *, FMOD_DSP_TYPE *))GetProcAddress(hFMOD, "FMOD_DSP_GetType");

         qFMOD_DSP_SetDefaults = (FMOD_RESULT (F_API *)(FMOD_DSP *, float, float, float, int))GetProcAddress(hFMOD, "FMOD_DSP_SetDefaults");

         qFMOD_DSP_GetDefaults = (FMOD_RESULT (F_API *)(FMOD_DSP *, float *, float *, float *, int *))GetProcAddress(hFMOD, "FMOD_DSP_GetDefaults");

         qFMOD_DSP_SetUserData = (FMOD_RESULT (F_API *)(FMOD_DSP *, void *))GetProcAddress(hFMOD, "FMOD_DSP_SetUserData");

         qFMOD_DSP_GetUserData = (FMOD_RESULT (F_API *)(FMOD_DSP *, void **))GetProcAddress(hFMOD, "FMOD_DSP_GetUserData");

         qFMOD_DSP_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_DSP *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_DSP_GetMemoryInfo");

         qFMOD_DSPConnection_GetInput = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetInput");

         qFMOD_DSPConnection_GetOutput = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, FMOD_DSP **))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetOutput");

         qFMOD_DSPConnection_SetMix = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, float))GetProcAddress(hFMOD, "FMOD_DSPConnection_SetMix");

         qFMOD_DSPConnection_GetMix = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, float *))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetMix");

         qFMOD_DSPConnection_SetLevels = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, FMOD_SPEAKER, float *, int))GetProcAddress(hFMOD, "FMOD_DSPConnection_SetLevels");

         qFMOD_DSPConnection_GetLevels = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, FMOD_SPEAKER, float *, int))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetLevels");

         qFMOD_DSPConnection_SetUserData = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, void *))GetProcAddress(hFMOD, "FMOD_DSPConnection_SetUserData");

         qFMOD_DSPConnection_GetUserData = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, void **))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetUserData");

         qFMOD_DSPConnection_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_DSPCONNECTION *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_DSPConnection_GetMemoryInfo");

         qFMOD_Geometry_Release = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *))GetProcAddress(hFMOD, "FMOD_Geometry_Release");

         qFMOD_Geometry_AddPolygon = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, float, float, FMOD_BOOL, int, const FMOD_VECTOR *, int *))GetProcAddress(hFMOD, "FMOD_Geometry_AddPolygon");

         qFMOD_Geometry_GetNumPolygons = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int *))GetProcAddress(hFMOD, "FMOD_Geometry_GetNumPolygons");

         qFMOD_Geometry_GetMaxPolygons = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int *, int *))GetProcAddress(hFMOD, "FMOD_Geometry_GetMaxPolygons");

         qFMOD_Geometry_GetPolygonNumVertices = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int, int *))GetProcAddress(hFMOD, "FMOD_Geometry_GetPolygonNumVertices");

         qFMOD_Geometry_SetPolygonVertex = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int, int, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_SetPolygonVertex");

         qFMOD_Geometry_GetPolygonVertex = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int, int, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_GetPolygonVertex");

         qFMOD_Geometry_SetPolygonAttributes = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int, float, float, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Geometry_SetPolygonAttributes");

         qFMOD_Geometry_GetPolygonAttributes = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, int, float *, float *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Geometry_GetPolygonAttributes");

         qFMOD_Geometry_SetActive = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Geometry_SetActive");

         qFMOD_Geometry_GetActive = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Geometry_GetActive");

         qFMOD_Geometry_SetRotation = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, const FMOD_VECTOR *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_SetRotation");

         qFMOD_Geometry_GetRotation = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, FMOD_VECTOR *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_GetRotation");

         qFMOD_Geometry_SetPosition = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_SetPosition");

         qFMOD_Geometry_GetPosition = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_GetPosition");

         qFMOD_Geometry_SetScale = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, const FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_SetScale");

         qFMOD_Geometry_GetScale = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, FMOD_VECTOR *))GetProcAddress(hFMOD, "FMOD_Geometry_GetScale");

         qFMOD_Geometry_Save = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, void *, int *))GetProcAddress(hFMOD, "FMOD_Geometry_Save");

         qFMOD_Geometry_SetUserData = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, void *))GetProcAddress(hFMOD, "FMOD_Geometry_SetUserData");

         qFMOD_Geometry_GetUserData = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, void **))GetProcAddress(hFMOD, "FMOD_Geometry_GetUserData");

         qFMOD_Geometry_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_GEOMETRY *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_Geometry_GetMemoryInfo");

         qFMOD_Reverb_Release = (FMOD_RESULT (F_API *)(FMOD_REVERB *))GetProcAddress(hFMOD, "FMOD_Reverb_Release");

         qFMOD_Reverb_Set3DAttributes = (FMOD_RESULT (F_API *)(FMOD_REVERB *, const FMOD_VECTOR *, float, float))GetProcAddress(hFMOD, "FMOD_Reverb_Set3DAttributes");

         qFMOD_Reverb_Get3DAttributes = (FMOD_RESULT (F_API *)(FMOD_REVERB *, FMOD_VECTOR *, float *, float *))GetProcAddress(hFMOD, "FMOD_Reverb_Get3DAttributes");

         qFMOD_Reverb_SetProperties = (FMOD_RESULT (F_API *)(FMOD_REVERB *, const FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_Reverb_SetProperties");

         qFMOD_Reverb_GetProperties = (FMOD_RESULT (F_API *)(FMOD_REVERB *, FMOD_REVERB_PROPERTIES *))GetProcAddress(hFMOD, "FMOD_Reverb_GetProperties");

         qFMOD_Reverb_SetActive = (FMOD_RESULT (F_API *)(FMOD_REVERB *, FMOD_BOOL))GetProcAddress(hFMOD, "FMOD_Reverb_SetActive");

         qFMOD_Reverb_GetActive = (FMOD_RESULT (F_API *)(FMOD_REVERB *, FMOD_BOOL *))GetProcAddress(hFMOD, "FMOD_Reverb_GetActive");

         qFMOD_Reverb_SetUserData = (FMOD_RESULT (F_API *)(FMOD_REVERB *, void *))GetProcAddress(hFMOD, "FMOD_Reverb_SetUserData");

         qFMOD_Reverb_GetUserData = (FMOD_RESULT (F_API *)(FMOD_REVERB *, void **))GetProcAddress(hFMOD, "FMOD_Reverb_GetUserData");

         qFMOD_Reverb_GetMemoryInfo = (FMOD_RESULT (F_API *)(FMOD_REVERB *, unsigned int, unsigned int, unsigned int *, FMOD_MEMORY_USAGE_DETAILS *))GetProcAddress(hFMOD, "FMOD_Reverb_GetMemoryInfo");

     }

 }

 void QFMOD_Shutdown(void)

 {

     if (hFMOD)

         FreeLibrary(hFMOD);

 }