changeset 8269:8b905703a450

- qtx (quicktime's macos emulation layer) debugging/emulation environment :) - some fixes in loadlibrary, to allow multiple loads/lookups

--- a/loader/Makefile	Sun Nov 24 21:43:17 2002 +0000
+++ b/loader/Makefile	Sun Nov 24 21:45:23 2002 +0000
@@ -6,7 +6,7 @@
 
 LIB_OBJECTS= ldt_keeper.o pe_image.o module.o \
 ext.o win32.o driver.o pe_resource.o \
-resource.o registry.o elfdll.o afl.o vfl.o
+resource.o registry.o elfdll.o afl.o vfl.o wrapper.o
 
 # gcc-3.0 produces buggy code for acmStreamOpen() with
 # "-O3 -fomit-frame-pointer" or "-O2 -fomit-frame-pointer

--- a/loader/module.c	Sun Nov 24 21:43:17 2002 +0000
+++ b/loader/module.c	Sun Nov 24 21:45:23 2002 +0000
@@ -3,6 +3,13 @@
  *
  * Copyright 1995 Alexandre Julliard
  */
+
+// define for quicktime calls debugging and/or MacOS-level emulation:
+//#define EMU_QTX_API
+
+// define for quicktime debugging (verbose logging):
+//#define DEBUG_QTX_API
+
 #include "config.h"
 
 #include <assert.h>
@@ -15,13 +22,15 @@
 #include <sys/mman.h>
 #include <sys/types.h>
 
-
 #include "wine/windef.h"
 #include "wine/winerror.h"
 #include "wine/heap.h"
 #include "wine/module.h"
 #include "wine/pe_image.h"
 #include "wine/debugtools.h"
+
+#undef HAVE_LIBDL
+
 #ifdef HAVE_LIBDL
 #include <dlfcn.h>
 #include "wine/elfdll.h"
@@ -29,6 +38,12 @@
 #include "win32.h"
 #include "driver.h"
 
+#ifdef EMU_QTX_API
+#include "wrapper.h"
+static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags);
+static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags);
+#endif
+
 //#undef TRACE
 //#define TRACE printf
 
@@ -43,7 +58,8 @@
     TRACE("Module %s request\n", m);
     if(list==NULL)
 	return NULL;
-    while(strcmp(m, list->wm->filename))
+//    while(strcmp(m, list->wm->filename))
+    while(!strstr(list->wm->filename, m))
     {
 	TRACE("%s: %x\n", list->wm->filename, list->wm->module);
 	list=list->prev;
@@ -295,6 +311,17 @@
 		/* decrement the dependencies through the MODULE_FreeLibrary call. */
 		pwm->refCount++;
 
+#ifdef EMU_QTX_API
+		if(strstr(libname,"QuickTime.qts")){
+		    void** ptr=0x62b75ca4;
+		    fprintf(stderr,"QuickTime.qts entrypoint patched!!! old=%p\n",ptr[0]);
+		    report_entry = report_func;
+		    report_ret   = report_func_ret;
+		    wrapper_target=ptr[0];
+		    ptr[0]=wrapper;
+		}
+#endif
+
                 SetLastError( err );  /* restore last error */
 		return pwm;
 	}
@@ -344,6 +371,10 @@
 		SetLastError(ERROR_INVALID_PARAMETER);
 		return 0;
 	}
+
+	wm=MODULE_FindModule(libname);
+	if(wm) return wm->module;
+
 //	if(fs_installed==0)
 //	    install_fs();
 
@@ -472,6 +503,337 @@
     return MODULE_GetProcAddress( hModule, function, TRUE );
 }
 
+#ifdef DEBUG_QTX_API
+
+struct ComponentParameters {
+    unsigned char                   flags;                      /* call modifiers: sync/async, deferred, immed, etc */
+    unsigned char                   paramSize;                  /* size in bytes of actual parameters passed to this call */
+    short                           what;                       /* routine selector, negative for Component management calls */
+    long                            params[1];                  /* actual parameters for the indicated routine */
+};
+typedef struct ComponentParameters      ComponentParameters;
+
+static char* component_func(int what){
+switch(what){
+case -1: return "kComponentOpenSelect";
+case -2: return "kComponentCloseSelect";
+case -3: return "kComponentCanDoSelect";
+case -4: return "kComponentVersionSelect";
+case -5: return "kComponentRegisterSelect";
+case -6: return "kComponentTargetSelect";
+case -7: return "kComponentUnregisterSelect";
+}
+return "???";
+}
+
+static char* component_func_type(int type,int what){
+if(type==1) switch(what){
+case 0: return "kImageCodecGetCodecInfoSelect";
+case 1: return "kImageCodecGetCompressionTimeSelect";
+case 5: return "kImageCodecPreDecompressSelect";
+case 6: return "kImageCodecBandDecompressSelect";
+case 0x12: return "kImageCodecDisposeMemorySelect";
+case 0x10: return "kImageCodecIsImageDescriptionEquivalentSelect";
+case 0x14: return "kImageCodecNewImageBufferMemorySelect";
+case 0x28: return "kImageCodecRequestGammaLevelSelect";
+}
+return "???";
+}
+
+
+static int c_level=0;
+
+static int dump_component(char* name,int type,void* _orig, ComponentParameters *params,void** glob){
+    int ( *orig)(ComponentParameters *params, void** glob) = _orig;
+    int ret,i;
+
+    if(params->what<0)
+	fprintf(stderr,"%*sComponentCall: %s  flags=0x%X  size=%d  what=%d %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func(params->what));
+    else
+	fprintf(stderr,"%*sComponentCall: %s  flags=0x%X  size=%d  what=0x%X %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func_type(type,params->what));
+
+    for(i=0;i<params->paramSize/4;i++)
+	fprintf(stderr,"%*s param[%d] = 0x%X\n",3*c_level,"",i,params->params[i]);
+
+    ++c_level;
+    ret=orig(params,glob);
+    --c_level;
+    
+    if(ret>=0x1000)
+	fprintf(stderr,"%*s return=0x%X\n",3*c_level,"",ret);
+    else
+	fprintf(stderr,"%*s return=%d\n",3*c_level,"",ret);
+    return ret;
+}
+
+#define DECL_COMPONENT(sname,name,type) \
+    static void* real_ ## sname = NULL; \
+    static int fake_ ## sname(ComponentParameters *params,void** glob){ \
+	return dump_component(name,type,real_ ## sname, params, glob); \
+    }
+
+#include "qt_comp.h"
+
+#undef DECL_COMPONENT
+
+#include "qt_fv.h"
+
+#endif
+
+#ifdef EMU_QTX_API
+
+static u_int32_t ret_array[4096];
+static int ret_i=0;
+
+static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags)
+{
+#ifdef DEBUG_QTX_API
+  int i;
+  int* dptr;
+  void* pwrapper=NULL;
+  void* pptr=NULL;
+  char* pname=NULL;
+  int plen=-1;
+  // find the code:
+  
+  dptr=0x62b67ae0;dptr+=2*((reg->eax>>16)&255);
+//  printf("FUNC: flag=%d ptr=%p\n",dptr[0],dptr[1]);
+  if(dptr[0]&255){
+      dptr=dptr[1];dptr+=4*(reg->eax&65535);
+//      printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",dptr[1],dptr[0],dptr[2]);
+      pwrapper=dptr[1]; pptr=dptr[0]; plen=dptr[2]; 
+  } else {
+      pwrapper=0x62924910;
+      switch(dptr[1]){
+      case 0x629248d0:
+          dptr=0x62b672c0;dptr+=2*(reg->eax&65535);
+//          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
+          pptr=dptr[0]; plen=dptr[1]; 
+	  break;
+      case 0x62924e40:
+          dptr=0x62b67c70;dptr+=2*(reg->eax&65535);
+//          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
+          pptr=dptr[0]; plen=dptr[1]; 
+	  break;
+      case 0x62924e60:
+          dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535);
+//          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
+          pptr=dptr[0]; plen=dptr[1]; 
+	  break;
+      case 0x62924e80:
+          dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535);
+//          printf("FUNC: ptr2=%p  eax=%p  edx=%p\n",0x62924910,dptr[0],dptr[1]);
+          pptr=dptr[0]; plen=dptr[1]; 
+	  break;
+      default:
+          printf("FUNC: unknown ptr & psize!\n");
+	  pwrapper=dptr[1];
+      }
+  }
+
+  for(i=0;qt_fv_list[i].name;i++){
+          if(qt_fv_list[i].id==reg->eax){
+	      pname=qt_fv_list[i].name;
+	      break;
+	  }
+  }
+
+  printf("FUNC[%X/%s]: wrapper=%p  func=%p  len=%d\n",reg->eax,
+      pname?pname:"???",pwrapper,pptr,plen);
+
+  printf("FUNC: caller=%p  ebx=%p\n",((u_int32_t *)stack_base)[0],reg->ebx);
+
+  if(pname)
+      printf("%*sENTER(%d): %s(",ret_i*2,"",ret_i,pname);
+  else
+      printf("%*sENTER(%d): %X(",ret_i*2,"",ret_i,reg->eax);
+  for (i=0;i<plen/4;i++){
+    unsigned int val=((u_int32_t *)stack_base)[1+i];
+    unsigned char* fcc=&val;
+    printf("%s0x%X", i?", ":"",val);
+    if(fcc[0]>=0x20 && fcc[0]<128 &&
+       fcc[1]>=0x20 && fcc[1]<128 &&
+       fcc[2]>=0x20 && fcc[2]<128 &&
+       fcc[3]>=0x20 && fcc[3]<128) printf("='%c%c%c%c'",fcc[3],fcc[2],fcc[1],fcc[0]);
+    else if(val>=8 && val<65536) printf("=%d",val);
+  }
+  printf(")\n");
+  fflush(stdout);
+
+#endif
+  
+#if 1
+  // emulate some functions:
+  switch(reg->eax){
+  // memory management:
+  case 0x150011: //NewPtrClear
+  case 0x150012: //NewPtrSysClear
+      reg->eax=malloc(((u_int32_t *)stack_base)[1]);
+      memset(reg->eax,0,((u_int32_t *)stack_base)[1]);
+#ifdef DEBUG_QTX_API
+      printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
+#endif
+      return 1;
+  case 0x15000F: //NewPtr
+  case 0x150010: //NewPtrSys
+      reg->eax=malloc(((u_int32_t *)stack_base)[1]);
+#ifdef DEBUG_QTX_API
+      printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
+#endif
+      return 1;
+  case 0x15002f: //DisposePtr
+      if(((u_int32_t *)stack_base)[1]>=0x60000000)
+          printf("WARNING! Invalid Ptr handle!\n");
+      else
+          free(((u_int32_t *)stack_base)[1]);
+      reg->eax=0;
+#ifdef DEBUG_QTX_API
+      printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
+#endif
+      return 1;
+  // mutexes:
+  case 0x1d0033: //QTMLCreateMutex
+      reg->eax=0xdeadbabe;
+#ifdef DEBUG_QTX_API
+      printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
+#endif
+      return 1;
+  case 0x1d0034: //QTMLDestroyMutex
+  case 0x1d0035: //QTMLGrabMutex
+  case 0x1d0036: //QTMLReturnMutex
+  case 0x1d003d: //QTMLTryGrabMutex
+      reg->eax=0;
+#ifdef DEBUG_QTX_API
+      printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax);
+#endif
+      return 1;
+  }
+#endif
+
+#if 0
+  switch(reg->eax){
+//  case 0x00010000:
+//      printf("FUNC: ImageCodecInitialize/ImageCodecGetCodecInfo(ci=%p,&icap=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[4]);
+//      break;
+  case 0x00010003:
+      printf("FUNC: CountComponents(&desc=%p)\n",((u_int32_t *)stack_base)[1]);
+      break;
+  case 0x00010004:
+      printf("FUNC: FindNextComponent(prev=%p,&desc=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[2]);
+      break;
+  case 0x00010007:
+      printf("FUNC: OpenComponent(prev=%p)\n",((u_int32_t *)stack_base)[1]);
+      break;
+  case 0x0003008b:
+      printf("FUNC: QTNewGWorldFromPtr(&pts=%p,fourcc=%.4s,&rect=%p,x1=%p,x2=%p,x3=%p,plane=%p,stride=%d)\n",
+          ((u_int32_t *)stack_base)[1],
+          &(((u_int32_t *)stack_base)[2]),
+          ((u_int32_t *)stack_base)[3],
+          ((u_int32_t *)stack_base)[4],
+          ((u_int32_t *)stack_base)[5],
+          ((u_int32_t *)stack_base)[6],
+          ((u_int32_t *)stack_base)[7],
+          ((u_int32_t *)stack_base)[8]);
+      break;
+  case 0x001c0018:
+      printf("FUNC: GetGWorldPixMap(gworld=%p)\n",((u_int32_t *)stack_base)[1]);
+      break;
+  case 0x00110001:
+      printf("FUNC: Gestalt(fourcc=%.4s, &ret=%p)\n",&(((u_int32_t *)stack_base)[1]),((u_int32_t *)stack_base)[2]);
+      break;
+  default: {
+      int i;
+      for(i=0;qt_fv_list[i].name;i++){
+          if(qt_fv_list[i].id==reg->eax){
+	      printf("FUNC: %s\n",qt_fv_list[i].name);
+	      break;
+	  }
+      }
+      }
+  }
+
+  // print stack/reg information 
+  printf("ENTER(%d) stack = %d bytes @ %p\n"
+	 "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n"
+	 "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n"
+	 "flags = 0x%08x\n", ret_i,
+	 stack_size, stack_base,
+	 reg->eax, reg->edx, reg->ebx, reg->ecx,
+	 reg->esp, reg->ebp, reg->esi, reg->edi,
+	 *flags);
+#endif
+
+  // save ret addr:
+  ret_array[ret_i]=((u_int32_t *)stack_base)[0];
+  ++ret_i;
+
+#if 0
+  // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) 
+  printf("stack[] = { ");
+  for (i=0;i<7;i++) {
+    printf("%08x ", ((u_int32_t *)stack_base)[i]);
+  }
+  printf("}\n\n");
+#endif
+  
+//  // mess with function parameters 
+//  ((u_int32_t *)stack_base)[1] = 0x66554433;
+
+//  // mess with return address...
+//  reg->eax = 0x11223344;
+    return 0;
+}
+
+static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags)
+{
+  int i;
+  short err;
+
+  // restore ret addr:
+  --ret_i;
+  ((u_int32_t *)stack_base)[0]=ret_array[ret_i];
+
+#ifdef DEBUG_QTX_API
+
+#if 1
+  printf("%*sLEAVE(%d): 0x%X",ret_i*2,"",ret_i, reg->eax);
+  err=reg->eax;
+  if(err && (reg->eax>>16)==0) printf(" = %d",err);
+  printf("\n");
+  fflush(stdout);
+#else
+  // print stack/reg information 
+  printf("LEAVE(%d) stack = %d bytes @ %p\n"
+	 "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n"
+	 "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n"
+	 "flags = 0x%08x\n", ret_i,
+	 stack_size, stack_base,
+	 reg->eax, reg->edx, reg->ebx, reg->ecx,
+	 reg->esp, reg->ebp, reg->esi, reg->edi,
+	 *flags);
+#endif
+
+#if 0
+  // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) 
+  printf("stack[] = { ");
+  for (i=0;i<7;i++) {
+    printf("%08x ", ((u_int32_t *)stack_base)[i]);
+  }
+  printf("}\n\n");
+#endif
+
+#endif
+  
+//  // mess with function parameters 
+//  ((u_int32_t *)stack_base)[1] = 0x66554433;
+
+//  // mess with return address...
+//  reg->eax = 0x11223344;
+    return 0;
+}
+
+#endif
+
 /***********************************************************************
  *           MODULE_GetProcAddress   		(internal)
  */
@@ -484,10 +846,17 @@
 //    WINE_MODREF *wm=local_wm;
     FARPROC	retproc;
 
+#ifdef DEBUG_QTX_API
     if (HIWORD(function))
-	TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function);
+	fprintf(stderr,"XXX GetProcAddress(%08lx,%s)\n",(DWORD)hModule,function);
     else
-	TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function);
+	fprintf(stderr,"XXX GetProcAddress(%08lx,%p)\n",(DWORD)hModule,function);
+#endif
+
+//	TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function);
+//    else
+//	TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function);
+
     if (!wm) {
     	SetLastError(ERROR_INVALID_HANDLE);
         return (FARPROC)0;
@@ -497,7 +866,7 @@
     case MODULE32_PE:
      	retproc = PE_FindExportedFunction( wm, function, snoop );
 	if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
-	return retproc;
+	break;
 #ifdef HAVE_LIBDL
     case MODULE32_ELF:
 	retproc = (FARPROC) dlsym( (void*) wm->module, function);
@@ -509,6 +878,35 @@
     	SetLastError(ERROR_INVALID_HANDLE);
     	return (FARPROC)0;
     }
+
+#ifdef EMU_QTX_API
+    if (HIWORD(function) && retproc){
+
+#ifdef DEBUG_QTX_API
+#define DECL_COMPONENT(sname,name,type) \
+    if(!strcmp(function,name)){ \
+	fprintf(stderr,name "dispatcher catched -> %p\n",retproc); \
+	real_ ## sname = retproc; retproc = fake_ ## sname; \
+    }
+#include "qt_comp.h"
+#undef DECL_COMPONENT
+#endif
+
+    if(!strcmp(function,"theQuickTimeDispatcher")
+//      || !strcmp(function,"_CallComponentFunctionWithStorage")
+//      || !strcmp(function,"_CallComponent")
+      ){
+	fprintf(stderr,"theQuickTimeDispatcher catched -> %p\n",retproc);
+      report_entry = report_func;
+      report_ret   = report_func_ret;
+      wrapper_target=retproc;
+      retproc=wrapper;
+    }
+
+    }
+#endif
+
+    return retproc;
 }
 
 static int acounter = 0;

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loader/qt_comp.h	Sun Nov 24 21:45:23 2002 +0000
@@ -0,0 +1,27 @@
+
+DECL_COMPONENT(sorenson3,"SMD_ComponentDispatch",1)
+DECL_COMPONENT(sorenson,"SorensonYUV9Dispatcher",1)
+DECL_COMPONENT(sorenson1,"SVD_ComponentDispatch",1)
+DECL_COMPONENT(genericd,"GenericComponentDispatch",0)
+DECL_COMPONENT(stmedia,"STMediaComponentDispatch",0)
+DECL_COMPONENT(handlecd,"HandleComponentDispatch",0)
+DECL_COMPONENT(pcxcd,"PCExchangeComponentDispatch",0)
+DECL_COMPONENT(capcd,"CapComponentDispatch",0)
+DECL_COMPONENT(videocd,"VideoComponentDispatch",0)
+DECL_COMPONENT(soundcd,"SoundComponentDispatch",0)
+DECL_COMPONENT(scalingcd,"ScalingCodecDispatcher",0)
+DECL_COMPONENT(formatcnv,"FormatConverterDispatch",0)
+
+DECL_COMPONENT(basecd,"Base_CDComponentDispatch",1)
+DECL_COMPONENT(ddcd,"DD_CDComponentDispatch",0)
+DECL_COMPONENT(fakergb,"FakeRGBDispatcher",0)
+DECL_COMPONENT(rawcd,"RAW_CDComponentDispatch",0)
+DECL_COMPONENT(yuvsgi,"YUVSGI_CDComponentDispatch",0)
+DECL_COMPONENT(yuvs,"YUVS_CDComponentDispatch",0)
+DECL_COMPONENT(yuvu,"YUVU_CDComponentDispatch",0)
+
+DECL_COMPONENT(qdm2d,"QDM2Decompressor",0)
+DECL_COMPONENT(mace3d,"Mace3DecompDispatch",0)
+
+//DECL_COMPONENT(,"",0)
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loader/qt_fv.h	Sun Nov 24 21:45:23 2002 +0000
@@ -0,0 +1,1586 @@
+typedef struct qt_fv_s {
+    unsigned int id;
+    char* name;
+} qt_fv_t;
+
+qt_fv_t qt_fv_list[]={
+{ 0x20001, "EnterMovies"},
+{ 0x20002, "ExitMovies"},
+{ 0x20003, "GetMoviesError"},
+{ 0x20004, "GetMoviesStickyError"},
+{ 0x20005, "MoviesTask"},
+{ 0x20006, "PrerollMovie"},
+{ 0x20007, "LoadMovieIntoRam"},
+{ 0x20008, "LoadMediaIntoRam"},
+{ 0x20009, "SetMovieActive"},
+{ 0x2000a, "GetMovieActive"},
+{ 0x2000b, "StartMovie"},
+{ 0x2000c, "StopMovie"},
+{ 0x2000d, "GoToBeginningOfMovie"},
+{ 0x2000e, "GoToEndOfMovie"},
+{ 0x2000f, "GetMoviePreviewMode"},
+{ 0x20010, "SetMoviePreviewMode"},
+{ 0x20011, "ShowMoviePoster"},
+{ 0x20012, "GetMovieTimeBase"},
+{ 0x20015, "GetMovieGWorld"},
+{ 0x20016, "SetMovieGWorld"},
+{ 0x2001d, "GetMoviePict"},
+{ 0x2001e, "GetTrackPict"},
+{ 0x2001f, "UpdateMovie"},
+{ 0x20022, "PutMovieIntoHandle"},
+{ 0x20023, "DisposeMovie"},
+{ 0x20026, "GetMovieCreationTime"},
+{ 0x20027, "GetMovieModificationTime"},
+{ 0x20029, "GetMovieTimeScale"},
+{ 0x2002a, "SetMovieTimeScale"},
+{ 0x2002b, "GetMovieDuration"},
+{ 0x2002c, "GetMovieRate"},
+{ 0x2002d, "SetMovieRate"},
+{ 0x2002e, "GetMovieVolume"},
+{ 0x2002f, "SetMovieVolume"},
+{ 0x20031, "GetMovieMatrix"},
+{ 0x20032, "SetMovieMatrix"},
+{ 0x20033, "GetMoviePreviewTime"},
+{ 0x20034, "SetMoviePreviewTime"},
+{ 0x20035, "GetMoviePosterTime"},
+{ 0x20036, "SetMoviePosterTime"},
+{ 0x20037, "GetMovieSelection"},
+{ 0x20038, "SetMovieSelection"},
+{ 0x20039, "GetMovieTime"},
+{ 0x2003c, "SetMovieTime"},
+{ 0x2003d, "SetMovieTimeValue"},
+{ 0x2003e, "GetMovieUserData"},
+{ 0x2003f, "GetMovieTrackCount"},
+{ 0x20040, "GetMovieTrack"},
+{ 0x20042, "DisposeMovieTrack"},
+{ 0x20043, "GetTrackCreationTime"},
+{ 0x20044, "GetTrackModificationTime"},
+{ 0x20045, "GetTrackEnabled"},
+{ 0x20046, "SetTrackEnabled"},
+{ 0x20047, "GetTrackUsage"},
+{ 0x20048, "SetTrackUsage"},
+{ 0x2004b, "GetTrackDuration"},
+{ 0x2004c, "GetTrackOffset"},
+{ 0x2004d, "SetTrackOffset"},
+{ 0x20050, "GetTrackLayer"},
+{ 0x20051, "SetTrackLayer"},
+{ 0x20052, "GetTrackAlternate"},
+{ 0x20053, "SetTrackAlternate"},
+{ 0x20054, "GetTrackVolume"},
+{ 0x20055, "SetTrackVolume"},
+{ 0x20056, "GetTrackMatrix"},
+{ 0x20057, "SetTrackMatrix"},
+{ 0x2005d, "GetTrackDimensions"},
+{ 0x2005e, "SetTrackDimensions"},
+{ 0x2005f, "GetTrackUserData"},
+{ 0x20061, "DisposeTrackMedia"},
+{ 0x20062, "GetTrackMedia"},
+{ 0x20066, "GetMediaCreationTime"},
+{ 0x20067, "GetMediaModificationTime"},
+{ 0x20068, "GetMediaTimeScale"},
+{ 0x20069, "SetMediaTimeScale"},
+{ 0x2006a, "GetMediaDuration"},
+{ 0x2006b, "GetMediaLanguage"},
+{ 0x2006c, "SetMediaLanguage"},
+{ 0x2006d, "GetMediaQuality"},
+{ 0x2006e, "SetMediaQuality"},
+{ 0x2006f, "GetMediaHandlerDescription"},
+{ 0x20070, "GetMediaUserData"},
+{ 0x20071, "GetMediaHandler"},
+{ 0x20072, "BeginMediaEdits"},
+{ 0x20073, "EndMediaEdits"},
+{ 0x20074, "AddEmptyTrackToMovie"},
+{ 0x20077, "GetMediaSampleDescriptionCount"},
+{ 0x20078, "GetMediaSampleDescription"},
+{ 0x20079, "GetMediaSampleCount"},
+{ 0x2007a, "SampleNumToMediaTime"},
+{ 0x2007b, "MediaTimeToSampleNum"},
+{ 0x2007c, "AddMediaSample"},
+{ 0x2007d, "AddMediaSampleReference"},
+{ 0x2007e, "GetMediaSample"},
+{ 0x2007f, "GetMediaSampleReference"},
+{ 0x20084, "CloneRgn"},
+{ 0x20085, "InsertTrackSegment"},
+{ 0x20086, "InsertMovieSegment"},
+{ 0x20087, "InsertEmptyTrackSegment"},
+{ 0x20088, "InsertEmptyMovieSegment"},
+{ 0x20089, "DeleteTrackSegment"},
+{ 0x2008a, "DeleteMovieSegment"},
+{ 0x2008b, "ScaleTrackSegment"},
+{ 0x2008c, "ScaleMovieSegment"},
+{ 0x2008d, "CutMovieSelection"},
+{ 0x2008e, "CopyMovieSelection"},
+{ 0x2008f, "PasteMovieSelection"},
+{ 0x20096, "TrackTimeToMediaTime"},
+{ 0x20098, "GetMovieDataSize"},
+{ 0x20099, "GetMediaDataSize"},
+{ 0x2009a, "PtInMovie"},
+{ 0x2009b, "PtInTrack"},
+{ 0x2009c, "SetMovieLanguage"},
+{ 0x2009d, "SetTrackGWorld"},
+{ 0x2009e, "GetUserData"},
+{ 0x2009f, "AddUserData"},
+{ 0x200a0, "RemoveUserData"},
+{ 0x200a5, "NewTimeBase"},
+{ 0x200a6, "GetTimeBaseTime"},
+{ 0x200a7, "SetTimeBaseTime"},
+{ 0x200a8, "SetTimeBaseValue"},
+{ 0x200a9, "GetTimeBaseRate"},
+{ 0x200aa, "SetTimeBaseRate"},
+{ 0x200ab, "GetTimeBaseStartTime"},
+{ 0x200ac, "SetTimeBaseStartTime"},
+{ 0x200ad, "GetTimeBaseStopTime"},
+{ 0x200ae, "SetTimeBaseStopTime"},
+{ 0x200af, "GetTimeBaseMasterTimeBase"},
+{ 0x200b0, "GetTimeBaseMasterClock"},
+{ 0x200b1, "GetTimeBaseFlags"},
+{ 0x200b2, "SetTimeBaseFlags"},
+{ 0x200b3, "SetTimeBaseMasterClock"},
+{ 0x200b4, "SetTimeBaseMasterTimeBase"},
+{ 0x200b5, "ConvertTime"},
+{ 0x200b6, "DisposeTimeBase"},
+{ 0x200b7, "ConvertTimeScale"},
+{ 0x200b8, "CallMeWhen"},
+{ 0x200b9, "CancelCallBack"},
+{ 0x200c5, "GetMediaTrack"},
+{ 0x200cb, "PasteHandleIntoMovie"},
+{ 0x200cc, "IsScrapMovie"},
+{ 0x200d0, "GetTrackMovie"},
+{ 0x200d5, "CloseMovieFile"},
+{ 0x200d7, "AddMovieResource"},
+{ 0x200d8, "UpdateMovieResource"},
+{ 0x200d9, "HasMovieChanged"},
+{ 0x200dd, "IsMovieDone"},
+{ 0x200de, "ClearMoviesStickyError"},
+{ 0x200e1, "ClearMovieSelection"},
+{ 0x200e2, "GetTrackNextInterestingTime"},
+{ 0x200eb, "NewCallBack"},
+{ 0x200ec, "DisposeCallBack"},
+{ 0x200ed, "GetCallBackType"},
+{ 0x200ee, "GetCallBackTimeBase"},
+{ 0x200ef, "SetMoviesErrorProc"},
+{ 0x200f0, "NewMovieFromFile"},
+{ 0x200f1, "NewMovieFromHandle"},
+{ 0x200f2, "PlayMoviePreview"},
+{ 0x200f3, "GetMoviePreferredRate"},
+{ 0x200f4, "SetMoviePreferredRate"},
+{ 0x200f5, "GetMoviePreferredVolume"},
+{ 0x200f6, "SetMoviePreferredVolume"},
+{ 0x200f7, "GetMoviePosterPict"},
+{ 0x200f9, "GetMovieBox"},
+{ 0x200fa, "SetMovieBox"},
+{ 0x200fb, "GetMovieDisplayBoundsRgn"},
+{ 0x200fc, "GetMovieDisplayClipRgn"},
+{ 0x200fd, "SetMovieDisplayClipRgn"},
+{ 0x200fe, "GetMovieBoundsRgn"},
+{ 0x200ff, "GetTrackMovieBoundsRgn"},
+{ 0x20100, "GetMovieClipRgn"},
+{ 0x20101, "SetMovieClipRgn"},
+{ 0x20102, "GetTrackClipRgn"},
+{ 0x20103, "SetTrackClipRgn"},
+{ 0x20104, "NewMovieEditState"},
+{ 0x20105, "UseMovieEditState"},
+{ 0x20106, "DisposeMovieEditState"},
+{ 0x20107, "NewTrackEditState"},
+{ 0x20108, "UseTrackEditState"},
+{ 0x20109, "DisposeTrackEditState"},
+{ 0x2010b, "GetTimeBaseStatus"},
+{ 0x2010c, "AddTime"},
+{ 0x2010d, "SubtractTime"},
+{ 0x2010e, "GetMovieNextInterestingTime"},
+{ 0x20111, "GetTrackBoundsRgn"},
+{ 0x20112, "GetTrackDisplayBoundsRgn"},
+{ 0x20113, "ClearMovieChanged"},
+{ 0x20115, "GetTrackMatte"},
+{ 0x20116, "SetTrackMatte"},
+{ 0x20117, "GetMovieIndTrack"},
+{ 0x20121, "SetMediaShadowSync"},
+{ 0x20122, "GetMediaShadowSync"},
+{ 0x20123, "GetTrackEditRate"},
+{ 0x20124, "GetTimeBaseEffectiveRate"},
+{ 0x20126, "GetUserDataItem"},
+{ 0x20127, "GetTrackID"},
+{ 0x20128, "SetTimeBaseZero"},
+{ 0x20129, "AddCallBackToTimeBase"},
+{ 0x2012a, "RemoveCallBackFromTimeBase"},
+{ 0x2012b, "GetFirstCallBack"},
+{ 0x2012c, "GetNextCallBack"},
+{ 0x2012d, "ExecuteCallBack"},
+{ 0x2012e, "SetUserDataItem"},
+{ 0x2012f, "NewUserData"},
+{ 0x20130, "DisposeUserData"},
+{ 0x20131, "NewUserDataFromHandle"},
+{ 0x20132, "PutUserDataIntoHandle"},
+{ 0x20149, "GetTrackDataSize"},
+{ 0x2014a, "DisposeMatte"},
+{ 0x2014b, "CountUserDataType"},
+{ 0x2014c, "AddUserDataText"},
+{ 0x2014d, "GetUserDataText"},
+{ 0x2014e, "RemoveUserDataText"},
+{ 0x20152, "AddMovieSelection"},
+{ 0x20153, "CopyTrackSettings"},
+{ 0x20154, "CopyMovieSettings"},
+{ 0x2015c, "SetMovieActiveSegment"},
+{ 0x2015d, "GetMovieActiveSegment"},
+{ 0x2015e, "SetAutoTrackAlternatesEnabled"},
+{ 0x2015f, "SelectMovieAlternates"},
+{ 0x20167, "SetMovieMasterTimeBase"},
+{ 0x20168, "SetMovieMasterClock"},
+{ 0x2016b, "GetTrackSegmentDisplayBoundsRgn"},
+{ 0x2016c, "GetMovieSegmentDisplayBoundsRgn"},
+{ 0x2016d, "GetMediaNextInterestingTime"},
+{ 0x2016e, "LoadTrackIntoRam"},
+{ 0x2016f, "GetPosterBox"},
+{ 0x20170, "SetPosterBox"},
+{ 0x20172, "GetTrackStatus"},
+{ 0x20173, "GetMovieStatus"},
+{ 0x20175, "DeleteMovieFile"},
+{ 0x20176, "RemoveMovieResource"},
+{ 0x20179, "SetMovieCoverProcs"},
+{ 0x20183, "InsertMediaIntoTrack"},
+{ 0x20187, "NewMovie"},
+{ 0x20188, "NewMovieTrack"},
+{ 0x2018a, "NewMovieController"},
+{ 0x2018b, "DisposeMovieController"},
+{ 0x2018c, "PutMovieOnScrap"},
+{ 0x2018d, "NewMovieFromScrap"},
+{ 0x2018e, "NewTrackMedia"},
+{ 0x20190, "SetMediaHandler"},
+{ 0x20191, "CreateMovieFile"},
+{ 0x20192, "OpenMovieFile"},
+{ 0x20197, "GetMediaDataRef"},
+{ 0x20198, "AddMediaDataRef"},
+{ 0x20199, "GetMediaDataRefCount"},
+{ 0x2019a, "SetMovieProgressProc"},
+{ 0x2019b, "FlattenMovie"},
+{ 0x2019c, "FlattenMovieData"},
+{ 0x2019e, "GetMediaDataHandlerDescription"},
+{ 0x2019f, "GetMediaDataHandler"},
+{ 0x201a0, "SetMediaDataHandler"},
+{ 0x201a1, "SetMoviePlayHints"},
+{ 0x201a2, "SetMediaPlayHints"},
+{ 0x201a5, "GetNextUserDataType"},
+{ 0x201b3, "NewMovieFromDataFork"},
+{ 0x201b4, "PutMovieIntoDataFork"},
+{ 0x201c1, "SetMovieDefaultDataRef"},
+{ 0x201c9, "SetMediaDataRef"},
+{ 0x201ca, "SetMediaDataRefAttributes"},
+{ 0x201cb, "ConvertFileToMovieFile"},
+{ 0x201cc, "ConvertMovieToFile"},
+{ 0x201cd, "PutMovieIntoTypedHandle"},
+{ 0x201d0, "SetMediaSampleDescription"},
+{ 0x201d2, "GetMovieDefaultDataRef"},
+{ 0x201dd, "GetMovieCoverProcs"},
+{ 0x201de, "SetMovieDrawingCompleteProc"},
+{ 0x201e0, "SetMediaDefaultDataRefIndex"},
+{ 0x201e3, "SetTrackLoadSettings"},
+{ 0x201e4, "GetTrackLoadSettings"},
+{ 0x201ec, "NewMovieFromUserProc"},
+{ 0x201ed, "GetDataHandler"},
+{ 0x201f0, "AddTrackReference"},
+{ 0x201f1, "DeleteTrackReference"},
+{ 0x201f2, "SetTrackReference"},
+{ 0x201f3, "GetTrackReference"},
+{ 0x201f4, "GetNextTrackReferenceType"},
+{ 0x201f5, "GetTrackReferenceCount"},
+{ 0x201f7, "AddMediaSampleReferences"},
+{ 0x201f8, "SetMediaPreferredChunkSize"},
+{ 0x201f9, "GetMediaPreferredChunkSize"},
+{ 0x201fa, "GetNextTrackForCompositing"},
+{ 0x201fb, "GetPrevTrackForCompositing"},
+{ 0x201ff, "QTSwapAtoms"},
+{ 0x20200, "QTNextChildAnyType"},
+{ 0x20201, "QTNewAlias"},
+{ 0x20205, "SetMovieColorTable"},
+{ 0x20206, "GetMovieColorTable"},
+{ 0x20207, "MovieSearchText"},
+{ 0x20208, "GetMovieIndTrackType"},
+{ 0x20209, "ShowMovieInformation"},
+{ 0x2020c, "QTNewAtomContainer"},
+{ 0x2020d, "QTDisposeAtomContainer"},
+{ 0x2020e, "QTGetNextChildType"},
+{ 0x2020f, "QTCountChildrenOfType"},
+{ 0x20210, "QTFindChildByIndex"},
+{ 0x20211, "QTSetAtomData"},
+{ 0x20212, "QTCopyAtomDataToHandle"},
+{ 0x20213, "QTCopyAtomDataToPtr"},
+{ 0x20214, "QTCopyAtom"},
+{ 0x20215, "QTLockContainer"},
+{ 0x20216, "QTGetAtomDataPtr"},
+{ 0x20217, "QTUnlockContainer"},
+{ 0x20218, "QTInsertChild"},
+{ 0x20219, "QTInsertChildren"},
+{ 0x2021a, "QTRemoveAtom"},
+{ 0x2021b, "QTRemoveChildren"},
+{ 0x2021c, "QTReplaceAtom"},
+{ 0x2021d, "QTFindChildByID"},
+{ 0x20220, "NewMovieFromDataRef"},
+{ 0x2022a, "InvalidateMovieRegion"},
+{ 0x2022b, "TaskMovie"},
+{ 0x2022c, "GetMovieNaturalBoundsRect"},
+{ 0x2022e, "SetMediaPropertyAtom"},
+{ 0x2022f, "GetMediaPropertyAtom"},
+{ 0x20231, "QTSetAtomID"},
+{ 0x20232, "QTGetAtomTypeAndID"},
+{ 0x20233, "BeginFullScreen"},
+{ 0x20234, "EndFullScreen"},
+{ 0x20235, "GetMediaSampleReferences"},
+{ 0x20239, "NewSpriteWorld"},
+{ 0x2023a, "DisposeSpriteWorld"},
+{ 0x2023b, "SetSpriteWorldClip"},
+{ 0x2023c, "SetSpriteWorldMatrix"},
+{ 0x2023d, "SpriteWorldIdle"},
+{ 0x2023e, "InvalidateSpriteWorld"},
+{ 0x2023f, "DisposeAllSprites"},
+{ 0x20240, "NewSprite"},
+{ 0x20241, "DisposeSprite"},
+{ 0x20242, "InvalidateSprite"},
+{ 0x20243, "SetSpriteProperty"},
+{ 0x20244, "GetSpriteProperty"},
+{ 0x20246, "SpriteWorldHitTest"},
+{ 0x20247, "SpriteHitTest"},
+{ 0x20249, "GetMediaInputMap"},
+{ 0x2024a, "SetMediaInputMap"},
+{ 0x20263, "GetTrackDisplayMatrix"},
+{ 0x2027a, "ITextAddString"},
+{ 0x2027b, "ITextRemoveString"},
+{ 0x2027c, "ITextGetString"},
+{ 0x20282, "GetTrackSoundLocalizationSettings"},
+{ 0x20283, "SetTrackSoundLocalizationSettings"},
+{ 0x20284, "SetMoviePropertyAtom"},
+{ 0x20285, "GetMoviePropertyAtom"},
+{ 0x2029d, "QTNewTween"},
+{ 0x2029e, "QTDoTween"},
+{ 0x2029f, "QTDisposeTween"},
+{ 0x202b2, "GetMediaSyncSampleCount"},
+{ 0x202b3, "QTGetAccessKeys"},
+{ 0x202b4, "QTRegisterAccessKey"},
+{ 0x202b5, "QTUnregisterAccessKey"},
+{ 0x202be, "MakeTrackTimeTable"},
+{ 0x202bf, "MakeMediaTimeTable"},
+{ 0x202c0, "GetMaxLoadedTimeInMovie"},
+{ 0x202c2, "SetSpriteWorldFlags"},
+{ 0x202c3, "QTMovieNeedsTimeTable"},
+{ 0x202c6, "QTGetDataRefMaxFileOffset"},
+{ 0x202c7, "GetMovieImporterForDataRef"},
+{ 0x202c9, "QTGetEffectsList"},
+{ 0x202ca, "QTCreateStandardParameterDialog"},
+{ 0x202cb, "QTIsStandardParameterDialogEvent"},
+{ 0x202cc, "QTDismissStandardParameterDialog"},
+{ 0x202cd, "QTStandardParameterDialogDoAction"},
+{ 0x202ce, "GetMediaPlayHints"},
+{ 0x202cf, "AddSoundDescriptionExtension"},
+{ 0x202d0, "GetSoundDescriptionExtension"},
+{ 0x202d1, "RemoveSoundDescriptionExtension"},
+{ 0x202d2, "QTGetEffectSpeed"},
+{ 0x202d3, "QuickTimeExtensionLoaded"},
+{ 0x202d4, "GetQuickTimePreference"},
+{ 0x202d5, "SetQuickTimePreference"},
+{ 0x202d9, "SetSpriteWorldGraphicsMode"},
+{ 0x202da, "CheckQuickTimeRegistration"},
+{ 0x202db, "QTTextToNativeText"},
+{ 0x202e8, "AddMediaSampleReferences64"},
+{ 0x202e9, "GetMediaSampleReferences64"},
+{ 0x202ea, "PutMovieIntoDataFork64"},
+{ 0x202eb, "GetMovieDataSize64"},
+{ 0x202ec, "GetTrackDataSize64"},
+{ 0x202ed, "GetMediaDataSize64"},
+{ 0x202ee, "NewMovieFromDataFork64"},
+{ 0x202ef, "QTGetAtomParent"},
+{ 0x202f1, "QTReportMissingSoftware"},
+{ 0x202f4, "InstallQuickTimeExtensionRequest"},
+{ 0x202f5, "QTBandwidthRequest"},
+{ 0x202f6, "QTBandwidthRelease"},
+{ 0x202f7, "PrePrerollMovie"},
+{ 0x202f8, "AbortPrePrerollMovie"},
+{ 0x202f9, "QTTempNewHandle"},
+{ 0x202fa, "CreateShortcutMovieFile"},
+{ 0x202fe, "QTAltGetComputerSpeed"},
+{ 0x20300, "GetMovieProgressProc"},
+{ 0x20302, "AddMovieExecuteWiredActionsProc"},
+{ 0x20303, "RemoveMovieExecuteWiredActionsProc"},
+{ 0x20304, "MovieExecuteWiredActions"},
+{ 0x20310, "QTScheduledBandwidthRequest"},
+{ 0x20311, "QTScheduledBandwidthRelease"},
+{ 0x20314, "GetMovieLoadState"},
+{ 0x20315, "SetMovieAnchorDataRef"},
+{ 0x20316, "GetMovieAnchorDataRef"},
+{ 0x20318, "QTBandwidthRequestForTimeBase"},
+{ 0x20319, "QTParseTextHREF"},
+{ 0x2031b, "QTDoCallBacks"},
+{ 0x2031c, "OpenADataHandler"},
+{ 0x2031d, "QTListNew"},
+{ 0x2031e, "QTListDispose"},
+{ 0x2031f, "QTListElementRefNew"},
+{ 0x20320, "QTListElementRefDispose"},
+{ 0x20321, "QTListElementRefGetList"},
+{ 0x20322, "QTListElementRefClone"},
+{ 0x20323, "QTListInsertNewElement"},
+{ 0x20324, "QTListSetElementDataAs"},
+{ 0x20325, "QTListSetElementName"},
+{ 0x20326, "QTListDeleteElement"},
+{ 0x20327, "QTListCutSublist"},
+{ 0x20328, "QTListCopySublist"},
+{ 0x20329, "QTListPasteSublist"},
+{ 0x2032a, "QTListDeleteSublist"},
+{ 0x2032b, "QTListSetMatchingElementData"},
+{ 0x2032c, "QTListCountChildElements"},
+{ 0x2032d, "QTListFindRootElement"},
+{ 0x2032e, "QTListFindParentElement"},
+{ 0x2032f, "QTListFindElementByName"},
+{ 0x20330, "QTListFindElementByIndex"},
+{ 0x20331, "QTListFindChildElementByPathName"},
+{ 0x20332, "QTListGetElementName"},
+{ 0x20333, "QTListGetElementPathName"},
+{ 0x20334, "QTListGetElementTypeAndSize"},
+{ 0x20335, "QTListGetElementIndex"},
+{ 0x20336, "QTListInsertNewAttribute"},
+{ 0x20337, "QTListCopyElementDataToPtr"},
+{ 0x20338, "QTListValidateDataType"},
+{ 0x20339, "QTListWriteToXML"},
+{ 0x2033a, "QTListReadFromXML"},
+{ 0x2033e, "CanQuickTimeOpenFile"},
+{ 0x2033f, "CanQuickTimeOpenDataRef"},
+{ 0x20340, "SetMovieVideoOutput"},
+{ 0x20344, "AddClonedTrackToMovie"},
+{ 0x20347, "QTGetWallClockTimeBase"},
+{ 0x2034f, "QTListDeleteAttribute"},
+{ 0x20350, "QTListCountAttributes"},
+{ 0x20351, "QTListFindAttributeByIndex"},
+{ 0x20352, "QTListFindAttributeByName"},
+{ 0x20353, "QTListFindAttributeParentElement"},
+{ 0x20354, "QTListSetAttributeDataAs"},
+{ 0x20355, "QTListSetAttributeName"},
+{ 0x20356, "QTListGetAttributeName"},
+{ 0x20357, "QTListAttributeRefNew"},
+{ 0x20358, "QTListAttributeRefDispose"},
+{ 0x20359, "QTListAttributeRefClone"},
+{ 0x2035a, "QTListGetAttributeTypeAndSize"},
+{ 0x2035b, "QTListGetAttributeIndex"},
+{ 0x2035c, "QTListCopyAttributeDataToPtr"},
+{ 0x190002, "NewPalette"},
+{ 0x190003, "GetNewPalette"},
+{ 0x190004, "DisposePalette"},
+{ 0x190005, "ActivatePalette"},
+{ 0x190006, "SetPalette"},
+{ 0x190007, "NSetPalette"},
+{ 0x190008, "GetPalette"},
+{ 0x190009, "CopyPalette"},
+{ 0x19000a, "PmForeColor"},
+{ 0x19000b, "PmBackColor"},
+{ 0x19000e, "GetEntryColor"},
+{ 0x19000f, "SetEntryColor"},
+{ 0x190010, "GetEntryUsage"},
+{ 0x190011, "SetEntryUsage"},
+{ 0x190012, "CTab2Palette"},
+{ 0x190013, "Palette2CTab"},
+{ 0x190014, "Entry2Index"},
+{ 0x190016, "MacResizePalette"},
+{ 0x190017, "SaveFore"},
+{ 0x190018, "SaveBack"},
+{ 0x190019, "RestoreFore"},
+{ 0x19001a, "RestoreBack"},
+{ 0x19001d, "PMgrVersion"},
+{ 0x19001e, "SetPaletteUpdates"},
+{ 0x19001f, "GetPaletteUpdates"},
+{ 0x190020, "GetGray"},
+{ 0x1e0002, "OpenPort"},
+{ 0x1e0003, "InitPort"},
+{ 0x1e0004, "ClosePort"},
+{ 0x1e0005, "MacSetPort"},
+{ 0x1e0006, "GetPort"},
+{ 0x1e0008, "SetPortBits"},
+{ 0x1e0009, "PortSize"},
+{ 0x1e000a, "MovePortTo"},
+{ 0x1e000b, "SetOrigin"},
+{ 0x1e000c, "SetClip"},
+{ 0x1e000d, "GetClip"},
+{ 0x1e000e, "ClipRect"},
+{ 0x1e000f, "BackPat"},
+{ 0x1e0010, "InitCursor"},
+{ 0x1e0011, "MacSetCursor"},
+{ 0x1e0012, "HideCursor"},
+{ 0x1e0013, "MacShowCursor"},
+{ 0x1e0014, "ObscureCursor"},
+{ 0x1e0015, "HidePen"},
+{ 0x1e0016, "ShowPen"},
+{ 0x1e0017, "GetPen"},
+{ 0x1e0018, "GetPenState"},
+{ 0x1e0019, "SetPenState"},
+{ 0x1e001a, "PenSize"},
+{ 0x1e001b, "PenMode"},
+{ 0x1e001c, "PenPat"},
+{ 0x1e001d, "PenNormal"},
+{ 0x1e001e, "MoveTo"},
+{ 0x1e001f, "Move"},
+{ 0x1e0020, "MacLineTo"},
+{ 0x1e0021, "Line"},
+{ 0x1e0022, "ForeColor"},
+{ 0x1e0023, "BackColor"},
+{ 0x1e0024, "ColorBit"},
+{ 0x1e0025, "MacSetRect"},
+{ 0x1e0026, "MacOffsetRect"},
+{ 0x1e0027, "MacInsetRect"},
+{ 0x1e0028, "SectRect"},
+{ 0x1e0029, "MacUnionRect"},
+{ 0x1e002a, "MacEqualRect"},
+{ 0x1e002b, "EmptyRect"},
+{ 0x1e002c, "MacFrameRect"},
+{ 0x1e002d, "PaintRect"},
+{ 0x1e002e, "EraseRect"},
+{ 0x1e002f, "MacInvertRect"},
+{ 0x1e0030, "MacFillRect"},
+{ 0x1e0031, "FrameOval"},
+{ 0x1e0032, "PaintOval"},
+{ 0x1e0033, "EraseOval"},
+{ 0x1e0034, "InvertOval"},
+{ 0x1e0035, "FillOval"},
+{ 0x1e0036, "FrameRoundRect"},
+{ 0x1e0037, "PaintRoundRect"},
+{ 0x1e0038, "EraseRoundRect"},
+{ 0x1e0039, "InvertRoundRect"},
+{ 0x1e003a, "FillRoundRect"},
+{ 0x1e003b, "FrameArc"},
+{ 0x1e003c, "PaintArc"},
+{ 0x1e003d, "EraseArc"},
+{ 0x1e003e, "InvertArc"},
+{ 0x1e003f, "FillArc"},
+{ 0x1e0040, "NewRgn"},
+{ 0x1e0041, "OpenRgn"},
+{ 0x1e0042, "CloseRgn"},
+{ 0x1e0043, "BitMapToRegion"},
+{ 0x1e0044, "DisposeRgn"},
+{ 0x1e0045, "MacCopyRgn"},
+{ 0x1e0046, "SetEmptyRgn"},
+{ 0x1e0047, "MacSetRectRgn"},
+{ 0x1e0048, "RectRgn"},
+{ 0x1e0049, "MacOffsetRgn"},
+{ 0x1e004a, "InsetRgn"},
+{ 0x1e004b, "SectRgn"},
+{ 0x1e004c, "MacUnionRgn"},
+{ 0x1e004d, "DiffRgn"},
+{ 0x1e004e, "MacXorRgn"},
+{ 0x1e004f, "RectInRgn"},
+{ 0x1e0050, "MacEqualRgn"},
+{ 0x1e0051, "EmptyRgn"},
+{ 0x1e0052, "MacFrameRgn"},
+{ 0x1e0053, "MacPaintRgn"},
+{ 0x1e0054, "EraseRgn"},
+{ 0x1e0055, "MacInvertRgn"},
+{ 0x1e0056, "MacFillRgn"},
+{ 0x1e0057, "ScrollRect"},
+{ 0x1e0058, "CopyBits"},
+{ 0x1e0059, "SeedFill"},
+{ 0x1e005a, "CalcMask"},
+{ 0x1e005b, "CopyMask"},
+{ 0x1e005c, "OpenPicture"},
+{ 0x1e005d, "PicComment"},
+{ 0x1e005e, "ClosePicture"},
+{ 0x1e005f, "DrawPicture"},
+{ 0x1e0060, "KillPicture"},
+{ 0x1e0061, "OpenPoly"},
+{ 0x1e0062, "ClosePoly"},
+{ 0x1e0063, "KillPoly"},
+{ 0x1e0064, "OffsetPoly"},
+{ 0x1e0065, "FramePoly"},
+{ 0x1e0066, "PaintPoly"},
+{ 0x1e0067, "ErasePoly"},
+{ 0x1e0068, "InvertPoly"},
+{ 0x1e0069, "FillPoly"},
+{ 0x1e006a, "SetPt"},
+{ 0x1e006b, "LocalToGlobal"},
+{ 0x1e006c, "GlobalToLocal"},
+{ 0x1e006d, "Random"},
+{ 0x1e006e, "StuffHex"},
+{ 0x1e006f, "MacGetPixel"},
+{ 0x1e0070, "ScalePt"},
+{ 0x1e0071, "MapPt"},
+{ 0x1e0072, "MapRect"},
+{ 0x1e0073, "MapRgn"},
+{ 0x1e0074, "MapPoly"},
+{ 0x1e0075, "SetStdProcs"},
+{ 0x1e0076, "StdRect"},
+{ 0x1e0077, "StdRRect"},
+{ 0x1e0078, "StdOval"},
+{ 0x1e0079, "StdArc"},
+{ 0x1e007a, "StdPoly"},
+{ 0x1e007b, "StdRgn"},
+{ 0x1e007c, "StdBits"},
+{ 0x1e007d, "StdComment"},
+{ 0x1e007e, "StdGetPic"},
+{ 0x1e007f, "StdPutPic"},
+{ 0x1e0080, "AddPt"},
+{ 0x1e0081, "EqualPt"},
+{ 0x1e0082, "MacPtInRect"},
+{ 0x1e0083, "Pt2Rect"},
+{ 0x1e0084, "PtToAngle"},
+{ 0x1e0085, "SubPt"},
+{ 0x1e0086, "PtInRgn"},
+{ 0x1e0087, "StdLine"},
+{ 0x1e0088, "OpenCPort"},
+{ 0x1e0089, "InitCPort"},
+{ 0x1e008a, "CloseCPort"},
+{ 0x1e008b, "NewPixMap"},
+{ 0x1e008c, "DisposePixMap"},
+{ 0x1e008d, "CopyPixMap"},
+{ 0x1e008e, "NewPixPat"},
+{ 0x1e008f, "DisposePixPat"},
+{ 0x1e0090, "CopyPixPat"},
+{ 0x1e0091, "PenPixPat"},
+{ 0x1e0092, "BackPixPat"},
+{ 0x1e0093, "GetPixPat"},
+{ 0x1e0094, "MakeRGBPat"},
+{ 0x1e0095, "FillCRect"},
+{ 0x1e0096, "FillCOval"},
+{ 0x1e0097, "FillCRoundRect"},
+{ 0x1e0098, "FillCArc"},
+{ 0x1e0099, "FillCRgn"},
+{ 0x1e009a, "FillCPoly"},
+{ 0x1e009b, "RGBForeColor"},
+{ 0x1e009c, "RGBBackColor"},
+{ 0x1e009d, "SetCPixel"},
+{ 0x1e009e, "SetPortPix"},
+{ 0x1e009f, "GetCPixel"},
+{ 0x1e00a0, "GetForeColor"},
+{ 0x1e00a1, "GetBackColor"},
+{ 0x1e00a2, "SeedCFill"},
+{ 0x1e00a3, "CalcCMask"},
+{ 0x1e00a4, "OpenCPicture"},
+{ 0x1e00a5, "OpColor"},
+{ 0x1e00a6, "HiliteColor"},
+{ 0x1e00a7, "DisposeCTable"},
+{ 0x1e00a8, "GetCTable"},
+{ 0x1e00a9, "GetCCursor"},
+{ 0x1e00aa, "SetCCursor"},
+{ 0x1e00ac, "DisposeCCursor"},
+{ 0x1e00b0, "SetStdCProcs"},
+{ 0x1e00b1, "GetMaxDevice"},
+{ 0x1e00b2, "GetCTSeed"},
+{ 0x1e00b3, "GetDeviceList"},
+{ 0x1e00b4, "GetMainDevice"},
+{ 0x1e00b5, "GetNextDevice"},
+{ 0x1e00b6, "TestDeviceAttribute"},
+{ 0x1e00b7, "SetDeviceAttribute"},
+{ 0x1e00b8, "InitGDevice"},
+{ 0x1e00b9, "NewGDevice"},
+{ 0x1e00ba, "DisposeGDevice"},
+{ 0x1e00bb, "SetGDevice"},
+{ 0x1e00bc, "GetGDevice"},
+{ 0x1e00bd, "Color2Index"},
+{ 0x1e00be, "Index2Color"},
+{ 0x1e00bf, "InvertColor"},
+{ 0x1e00c0, "RealColor"},
+{ 0x1e00c1, "GetSubTable"},
+{ 0x1e00c2, "MakeITable"},
+{ 0x1e00c3, "AddSearch"},
+{ 0x1e00c4, "AddComp"},
+{ 0x1e00c5, "DelSearch"},
+{ 0x1e00c6, "DelComp"},
+{ 0x1e00c7, "SetClientID"},
+{ 0x1e00c8, "ProtectEntry"},
+{ 0x1e00c9, "ReserveEntry"},
+{ 0x1e00ca, "SetEntries"},
+{ 0x1e00cb, "SaveEntries"},
+{ 0x1e00cc, "RestoreEntries"},
+{ 0x1e00cd, "QDError"},
+{ 0x1e00ce, "CopyDeepMask"},
+{ 0x1e00cf, "DeviceLoop"},
+{ 0x1e00d3, "MacGetCursor"},
+{ 0x1e00d4, "GetPicture"},
+{ 0x1e00d6, "ShieldCursor"},
+{ 0x1e00d9, "PackBits"},
+{ 0x1e00da, "UnpackBits"},
+{ 0x1e00db, "SlopeFromAngle"},
+{ 0x1e00dc, "AngleFromSlope"},
+{ 0x1e00dd, "LockPortBits"},
+{ 0x1e00de, "UnlockPortBits"},
+{ 0x1e00e1, "UpdatePort"},
+{ 0x1e00e4, "CopyBitsGDI"},
+{ 0x30000, "CodecManagerVersion"},
+{ 0x30001, "GetCodecNameList"},
+{ 0x30003, "GetCodecInfo"},
+{ 0x30004, "GetMaxCompressionSize"},
+{ 0x30005, "GetCompressionTime"},
+{ 0x30006, "CompressImage"},
+{ 0x30007, "FCompressImage"},
+{ 0x30008, "DecompressImage"},
+{ 0x30009, "FDecompressImage"},
+{ 0x3000a, "CompressSequenceBegin"},
+{ 0x3000b, "CompressSequenceFrame"},
+{ 0x3000c, "StdPix"},
+{ 0x3000d, "DecompressSequenceBegin"},
+{ 0x3000e, "DecompressSequenceFrame"},
+{ 0x3000f, "DisposeCodecNameList"},
+{ 0x30010, "SetDSequenceMatrix"},
+{ 0x30011, "SetDSequenceMatte"},
+{ 0x30012, "SetDSequenceMask"},
+{ 0x30013, "SetDSequenceTransferMode"},
+{ 0x30014, "SetDSequenceDataProc"},
+{ 0x30015, "GetDSequenceImageBuffer"},
+{ 0x30016, "GetDSequenceScreenBuffer"},
+{ 0x30017, "SetCSequenceQuality"},
+{ 0x30018, "SetCSequencePrev"},
+{ 0x30019, "GetCSequencePrevBuffer"},
+{ 0x3001a, "CDSequenceBusy"},
+{ 0x3001b, "CDSequenceEnd"},
+{ 0x3001c, "GetCompressedImageSize"},
+{ 0x3001d, "GetSimilarity"},
+{ 0x3001e, "GetImageDescriptionCTable"},
+{ 0x3001f, "SetImageDescriptionCTable"},
+{ 0x30020, "GetImageDescriptionExtension"},
+{ 0x30021, "AddImageDescriptionExtension"},
+{ 0x30023, "FindCodec"},
+{ 0x30024, "CompressPicture"},
+{ 0x30025, "FCompressPicture"},
+{ 0x30026, "CompressPictureFile"},
+{ 0x30027, "FCompressPictureFile"},
+{ 0x30028, "GetPictureFileHeader"},
+{ 0x30029, "DrawPictureFile"},
+{ 0x3002a, "MakeThumbnailFromPicture"},
+{ 0x3002b, "MakeThumbnailFromPictureFile"},
+{ 0x3002c, "MakeThumbnailFromPixMap"},
+{ 0x3002d, "TrimImage"},
+{ 0x3002e, "DrawTrimmedPicture"},
+{ 0x3002f, "DrawTrimmedPictureFile"},
+{ 0x30030, "ConvertImage"},
+{ 0x30033, "SetCSequenceFlushProc"},
+{ 0x30034, "SetDSequenceAccuracy"},
+{ 0x30035, "SetDSequenceSrcRect"},
+{ 0x30036, "SetCSequenceKeyFrameRate"},
+{ 0x30037, "GetCompressedPixMapInfo"},
+{ 0x30038, "SetCompressedPixMapInfo"},
+{ 0x30039, "TransformRgn"},
+{ 0x3003a, "RemoveImageDescriptionExtension"},
+{ 0x3003b, "CountImageDescriptionExtensionType"},
+{ 0x3003c, "GetNextImageDescriptionExtensionType"},
+{ 0x30041, "SFGetFilePreview"},
+{ 0x30042, "SFPGetFilePreview"},
+{ 0x30043, "StandardGetFilePreview"},
+{ 0x30044, "CustomGetFilePreview"},
+{ 0x30045, "MakeFilePreview"},
+{ 0x30046, "AddFilePreview"},
+{ 0x30047, "DecompressSequenceFrameS"},
+{ 0x3004b, "GetCSequenceKeyFrameRate"},
+{ 0x3004c, "AlignScreenRect"},
+{ 0x3004d, "AlignWindow"},
+{ 0x3004e, "DragAlignedWindow"},
+{ 0x3004f, "DragAlignedGrayRgn"},
+{ 0x30050, "SetCSequenceDataRateParams"},
+{ 0x30051, "SetCSequenceFrameNumber"},
+{ 0x30052, "NewImageGWorld"},
+{ 0x30053, "GetCSequenceDataRateParams"},
+{ 0x30054, "GetCSequenceFrameNumber"},
+{ 0x30055, "GetBestDeviceRect"},
+{ 0x30056, "SetSequenceProgressProc"},
+{ 0x30057, "SetDSequenceFlags"},
+{ 0x3005a, "GDHasScale"},
+{ 0x3005b, "GDGetScale"},
+{ 0x3005c, "GDSetScale"},
+{ 0x3005d, "DecompressSequenceBeginS"},
+{ 0x3005e, "DecompressSequenceFrameWhen"},
+{ 0x3005f, "CDSequenceFlush"},
+{ 0x30061, "QTGetFileNameExtension"},
+{ 0x30062, "ICMShieldSequenceCursor"},
+{ 0x30063, "ICMDecompressComplete"},
+{ 0x30064, "SetDSequenceTimeCode"},
+{ 0x30065, "CDSequenceEquivalentImageDescription"},
+{ 0x30066, "CDSequenceNewMemory"},
+{ 0x30067, "CDSequenceDisposeMemory"},
+{ 0x30068, "CDSequenceNewDataSource"},
+{ 0x30069, "CDSequenceDisposeDataSource"},
+{ 0x3006a, "CDSequenceSetSourceData"},
+{ 0x3006b, "CDSequenceChangedSourceData"},
+{ 0x3006c, "PtInDSequenceData"},
+{ 0x3006d, "ImageFieldSequenceBegin"},
+{ 0x3006e, "GetGraphicsImporterForFile"},
+{ 0x3006f, "ImageTranscodeSequenceBegin"},
+{ 0x30070, "ImageTranscodeSequenceEnd"},
+{ 0x30071, "ImageTranscodeFrame"},
+{ 0x30072, "ImageTranscodeDisposeFrameData"},
+{ 0x30073, "CDSequenceInvalidate"},
+{ 0x30074, "GetCSequenceMaxCompressionSize"},
+{ 0x30075, "ImageFieldSequenceExtractCombine"},
+{ 0x30076, "ImageFieldSequenceEnd"},
+{ 0x30077, "GetGraphicsImporterForDataRef"},
+{ 0x30078, "SetCSequencePreferredPacketSize"},
+{ 0x30079, "CDSequenceSetTimeBase"},
+{ 0x3007a, "MakeImageDescriptionForPixMap"},
+{ 0x3007b, "CDSequenceSetSourceDataQueue"},
+{ 0x3007c, "ICMSequenceLockBits"},
+{ 0x3007d, "ICMSequenceUnlockBits"},
+{ 0x3007e, "ICMSequenceGetChainMember"},
+{ 0x3007f, "CDSequenceGetDataSource"},
+{ 0x30080, "QTNewGWorld"},
+{ 0x30081, "QTUpdateGWorld"},
+{ 0x30082, "ICMDecompressCompleteS"},
+{ 0x30083, "ICMGetPixelFormatInfo"},
+{ 0x30084, "GetGraphicsImporterForFileWithFlags"},
+{ 0x30085, "GetGraphicsImporterForDataRefWithFlags"},
+{ 0x30086, "QTGetPixelSize"},
+{ 0x30087, "HitTestDSequenceData"},
+{ 0x30089, "ICMSequenceGetInfo"},
+{ 0x3008a, "ICMSetPixelFormatInfo"},
+{ 0x3008b, "QTNewGWorldFromPtr"},
+{ 0x3008d, "QTGetPixMapPtrRowBytes"},
+{ 0x3008e, "QTGetPixMapHandleRowBytes"},
+{ 0x3008f, "QTSetPixMapHandleRowBytes"},
+{ 0x30090, "QTSetPixMapPtrRowBytes"},
+{ 0x30091, "GetDSequenceMatrix"},
+{ 0x30092, "MakeImageDescriptionForEffect"},
+{ 0x30093, "QTGetPixMapPtrGammaLevel"},
+{ 0x30094, "QTSetPixMapPtrGammaLevel"},
+{ 0x30095, "QuadToQuadMatrix"},
+{ 0x30096, "QTGetPixMapHandleGammaLevel"},
+{ 0x30097, "QTSetPixMapHandleGammaLevel"},
+{ 0x30098, "QTGetPixMapPtrRequestedGammaLevel"},
+{ 0x30099, "QTSetPixMapPtrRequestedGammaLevel"},
+{ 0x3009a, "QTGetPixMapHandleRequestedGammaLevel"},
+{ 0x3009b, "QTSetPixMapHandleRequestedGammaLevel"},
+{ 0x3009c, "OpenPreviewComponentForFile"},
+{ 0x3009d, "ICMSequenceSetInfo"},
+{ 0x3009f, "CDSequenceEquivalentImageDescriptionS"},
+{ 0x300a0, "ReplaceDSequenceImageDescription"},
+{ 0x200003, "CloseResFile"},
+{ 0x200004, "ResError"},
+{ 0x200005, "CurResFile"},
+{ 0x200006, "HomeResFile"},
+{ 0x200009, "UseResFile"},
+{ 0x20000a, "CountTypes"},
+{ 0x20000b, "Count1Types"},
+{ 0x20000c, "GetIndType"},
+{ 0x20000d, "Get1IndType"},
+{ 0x20000e, "SetResLoad"},
+{ 0x20000f, "CountResources"},
+{ 0x200010, "Count1Resources"},
+{ 0x200011, "GetIndResource"},
+{ 0x200012, "Get1IndResource"},
+{ 0x200013, "GetResource"},
+{ 0x200014, "Get1Resource"},
+{ 0x200015, "GetNamedResource"},
+{ 0x200016, "Get1NamedResource"},
+{ 0x200017, "MacLoadResource"},
+{ 0x200018, "ReleaseResource"},
+{ 0x200019, "DetachResource"},
+{ 0x20001a, "UniqueID"},
+{ 0x20001b, "Unique1ID"},
+{ 0x20001c, "GetResAttrs"},
+{ 0x20001d, "GetResInfo"},
+{ 0x20001e, "SetResInfo"},
+{ 0x20001f, "AddResource"},
+{ 0x200020, "GetResourceSizeOnDisk"},
+{ 0x200023, "SetResAttrs"},
+{ 0x200024, "ChangedResource"},
+{ 0x200025, "RemoveResource"},
+{ 0x200026, "UpdateResFile"},
+{ 0x200027, "WriteResource"},
+{ 0x200028, "SetResPurge"},
+{ 0x200029, "GetResFileAttrs"},
+{ 0x20002a, "SetResFileAttrs"},
+{ 0x20002f, "FSpOpenResFile"},
+{ 0x200030, "FSpCreateResFile"},
+{ 0x200033, "SetResourceSize"},
+{ 0x200036, "RegisterResourceEndianFilter"},
+{ 0x200037, "GetIndString"},
+{ 0x0c0003, "NewDialog"},
+{ 0x0c0004, "GetNewDialog"},
+{ 0x0c0006, "CloseDialog"},
+{ 0x0c0007, "DisposeDialog"},
+{ 0x0c0008, "ModalDialog"},
+{ 0x0c0009, "IsDialogEvent"},
+{ 0x0c000a, "DialogSelect"},
+{ 0x0c000b, "DrawDialog"},
+{ 0x0c000c, "UpdateDialog"},
+{ 0x0c000d, "HideDialogItem"},
+{ 0x0c000e, "ShowDialogItem"},
+{ 0x0c000f, "FindDialogItem"},
+{ 0x0c0014, "Alert"},
+{ 0x0c0015, "StopAlert"},
+{ 0x0c0016, "NoteAlert"},
+{ 0x0c0017, "CautionAlert"},
+{ 0x0c0018, "GetDialogItem"},
+{ 0x0c0019, "SetDialogItem"},
+{ 0x0c001a, "ParamText"},
+{ 0x0c001b, "SelectDialogItemText"},
+{ 0x0c001c, "GetDialogItemText"},
+{ 0x0c001d, "SetDialogItemText"},
+{ 0x0c0021, "AppendDITL"},
+{ 0x0c0022, "CountDITL"},
+{ 0x0c0023, "ShortenDITL"},
+{ 0x0c0024, "StdFilterProc"},
+{ 0x0c0025, "GetStdFilterProc"},
+{ 0x0c0026, "SetDialogDefaultItem"},
+{ 0x0c0027, "SetDialogCancelItem"},
+{ 0x0c0028, "SetDialogTracksCursor"},
+{ 0x0c002d, "NewColorDialog"},
+{ 0x0c002e, "SetModelessDialogCallbackProc"},
+{ 0x0c002f, "GetDialogItemAsControl"},
+{ 0x0c0030, "SetDialogMovableModal"},
+{ 0x0c0031, "MoveDialogItem"},
+{ 0x0c0032, "SizeDialogItem"},
+{ 0x1c0001, "NewGWorld"},
+{ 0x1c0002, "LockPixels"},
+{ 0x1c0003, "UnlockPixels"},
+{ 0x1c0004, "UpdateGWorld"},
+{ 0x1c0005, "DisposeGWorld"},
+{ 0x1c0006, "GetGWorld"},
+{ 0x1c0007, "SetGWorld"},
+{ 0x1c0008, "CTabChanged"},
+{ 0x1c0009, "PixPatChanged"},
+{ 0x1c000a, "PortChanged"},
+{ 0x1c000b, "GDeviceChanged"},
+{ 0x1c000c, "AllowPurgePixels"},
+{ 0x1c000d, "NoPurgePixels"},
+{ 0x1c000e, "GetPixelsState"},
+{ 0x1c000f, "SetPixelsState"},
+{ 0x1c0010, "GetPixBaseAddr"},
+{ 0x1c0011, "NewScreenBuffer"},
+{ 0x1c0012, "DisposeScreenBuffer"},
+{ 0x1c0013, "GetGWorldDevice"},
+{ 0x1c0014, "QDDone"},
+{ 0x1c0015, "OffscreenVersion"},
+{ 0x1c0016, "NewTempScreenBuffer"},
+{ 0x1c0017, "PixMap32Bit"},
+{ 0x1c0018, "GetGWorldPixMap"},
+{ 0x1c0019, "NewGWorldFromPtr"},
+{ 0x160001, "GetMBarHeight"},
+{ 0x160002, "NewMenu"},
+{ 0x160003, "MacGetMenu"},
+{ 0x160004, "MacAppendMenu"},
+{ 0x160005, "MacInsertMenu"},
+{ 0x160006, "MacDeleteMenu"},
+{ 0x160007, "AppendResMenu"},
+{ 0x160008, "MacInsertMenuItem"},
+{ 0x160009, "SetMenuItemText"},
+{ 0x16000a, "GetMenuItemText"},
+{ 0x16000b, "SetItemMark"},
+{ 0x16000c, "GetItemMark"},
+{ 0x16000d, "SetItemCmd"},
+{ 0x16000e, "GetItemCmd"},
+{ 0x16000f, "SetItemIcon"},
+{ 0x160010, "GetItemIcon"},
+{ 0x160011, "SetItemStyle"},
+{ 0x160012, "GetItemStyle"},
+{ 0x160013, "GetMenuHandle"},
+{ 0x160014, "CalcMenuSize"},
+{ 0x160015, "DisableItem"},
+{ 0x160016, "EnableItem"},
+{ 0x160017, "FlashMenuBar"},
+{ 0x160018, "PopUpMenuSelect"},
+{ 0x16001f, "MacDrawMenuBar"},
+{ 0x160020, "InvalMenuBar"},
+{ 0x160021, "InitProcMenu"},
+{ 0x160022, "GetMenuBar"},
+{ 0x160023, "SetMenuBar"},
+{ 0x160024, "SystemEdit"},
+{ 0x160025, "SystemMenu"},
+{ 0x160026, "GetNewMBar"},
+{ 0x160027, "ClearMenuBar"},
+{ 0x160028, "CheckItem"},
+{ 0x160029, "CountMItems"},
+{ 0x16002a, "SetMenuFlash"},
+{ 0x16002b, "InitMenus"},
+{ 0x16002c, "MenuKey"},
+{ 0x16002d, "MenuSelect"},
+{ 0x16002e, "MenuChoice"},
+{ 0x16002f, "DisposeMenu"},
+{ 0x160030, "DeleteMenuItem"},
+{ 0x160031, "HiliteMenu"},
+{ 0x160032, "InsertResMenu"},
+{ 0x160033, "InsertFontResMenu"},
+{ 0x160034, "InsertIntlResMenu"},
+
+{ 0x1d0001, "CreatePortAssociation"},
+{ 0x1d0002, "DestroyPortAssociation"},
+{ 0x1d0003, "GetNativeWindowPort"},
+{ 0x1d0004, "GetPortNativeWindow"},
+{ 0x1d0008, "QTMLInitInternals"},
+{ 0x1d0009, "QTMLTermInternals"},
+{ 0x1d000a, "NativeEventToMacEvent"},
+{ 0x1d000e, "RegisterAbortAction"},
+{ 0x1d000f, "UnregisterAbortAction"},
+{ 0x1d0010, "InitializeQHdr"},
+{ 0x1d0011, "TerminateQHdr"},
+{ 0x1d0012, "QTMLYieldCPU"},
+{ 0x1d0013, "QTMLRegisterInterruptSafeThread"},
+{ 0x1d0014, "QTMLUnregisterInterruptSafeThread"},
+{ 0x1d0017, "Endian64_Swap"},
+{ 0x1d0019, "GetColor"},
+{ 0x1d001a, "FindFolderEx"},
+{ 0x1d001d, "ldtox80"},
+{ 0x1d001e, "x80told"},
+{ 0x1d0021, "Debugger"},
+{ 0x1d0022, "DebugStr"},
+{ 0x1d0024, "QTMLYieldCPUTime"},
+{ 0x1d0027, "QTMLGetCanonicalPathName"},
+{ 0x1d0028, "QTMLGetVolumeRootPath"},
+{ 0x1d0029, "QTMLAcquireWindowList"},
+{ 0x1d002a, "QTMLReleaseWindowList"},
+{ 0x1d002b, "NativeRegionToMacRegion"},
+{ 0x1d002c, "MacRegionToNativeRegion"},
+{ 0x1d002d, "FSSpecToNativePathName"},
+{ 0x1d002e, "NativePathNameToFSSpec"},
+
+{ 0x1d0033, "QTMLCreateMutex"},
+{ 0x1d0034, "QTMLDestroyMutex"},
+{ 0x1d0035, "QTMLGrabMutex"},
+{ 0x1d0036, "QTMLReturnMutex"},
+
+{ 0x1d0037, "QTMLCreateSyncVar"},
+{ 0x1d0038, "QTMLDestroySyncVar"},
+{ 0x1d0039, "QTMLTestAndSetSyncVar"},
+{ 0x1d003a, "QTMLWaitAndSetSyncVar"},
+{ 0x1d003b, "QTMLResetSyncVar"},
+
+{ 0x1d003d, "QTMLTryGrabMutex"},
+
+{ 0x1d004e, "QTMLGetDirectXObject"},
+{ 0x1d004f, "QTMLSetDirectXObject"},
+{ 0x1d0052, "QTGetAliasInfo"},
+
+{ 0x170001, "NewGWorldFromHBITMAP"},
+{ 0x170003, "QTSetDDPrimarySurface"},
+{ 0x170004, "QTGetDDObject"},
+{ 0x170005, "QTMLSetWindowWndProc"},
+{ 0x170006, "QTMLGetWindowWndProc"},
+{ 0x170007, "GetPortHDC"},
+{ 0x170008, "GetPortHBITMAP"},
+{ 0x170009, "GetPortHPALETTE"},
+{ 0x17000a, "GetPortHFONT"},
+{ 0x17000b, "ShowHideTaskBar"},
+{ 0x17000c, "IsTaskBarVisible"},
+{ 0x17000e, "QTSetDDObject"},
+{ 0x17000f, "GetDIBFromPICT"},
+{ 0x170010, "GetPICTFromDIB"},
+{ 0x170011, "GetGDeviceSurface"},
+{ 0x170012, "GetGDeviceAttributes"},
+{ 0x150002, "SystemZone"},
+{ 0x150003, "ApplicationZone"},
+{ 0x150006, "MemError"},
+{ 0x150007, "GetZone"},
+{ 0x150008, "NewHandle"},
+{ 0x150009, "NewHandleSys"},
+{ 0x15000a, "NewHandleClear"},
+{ 0x15000b, "NewHandleSysClear"},
+{ 0x15000c, "HandleZone"},
+{ 0x15000d, "RecoverHandle"},
+{ 0x15000f, "NewPtr"},
+{ 0x150010, "NewPtrSys"},
+{ 0x150011, "NewPtrClear"},
+{ 0x150012, "NewPtrSysClear"},
+{ 0x150013, "PtrZone"},
+{ 0x150014, "MaxBlock"},
+{ 0x150015, "MaxBlockSys"},
+{ 0x150017, "NewEmptyHandle"},
+{ 0x150018, "NewEmptyHandleSys"},
+{ 0x150019, "HLock"},
+{ 0x15001a, "HUnlock"},
+{ 0x15001b, "HPurge"},
+{ 0x15001c, "HNoPurge"},
+{ 0x15001d, "HLockHi"},
+{ 0x15001e, "TempNewHandle"},
+{ 0x15001f, "TempMaxMem"},
+{ 0x150020, "TempFreeMem"},
+{ 0x150022, "SetZone"},
+{ 0x150023, "CompactMem"},
+{ 0x150024, "CompactMemSys"},
+{ 0x150025, "PurgeMem"},
+{ 0x150026, "PurgeMemSys"},
+{ 0x150027, "FreeMem"},
+{ 0x150028, "FreeMemSys"},
+{ 0x150029, "ReserveMem"},
+{ 0x15002a, "ReserveMemSys"},
+{ 0x15002b, "MaxMem"},
+{ 0x15002c, "MaxMemSys"},
+{ 0x15002e, "MoveHHi"},
+{ 0x15002f, "DisposePtr"},
+{ 0x150030, "GetPtrSize"},
+{ 0x150031, "SetPtrSize"},
+{ 0x150032, "DisposeHandle"},
+{ 0x150033, "SetHandleSize"},
+{ 0x150034, "GetHandleSize"},
+{ 0x150036, "ReallocateHandle"},
+{ 0x150038, "EmptyHandle"},
+{ 0x15003b, "HGetState"},
+{ 0x15003c, "HSetState"},
+{ 0x15003d, "PurgeSpace"},
+{ 0x15003e, "BlockMove"},
+{ 0x15003f, "BlockMoveData"},
+{ 0x150045, "TempHLock"},
+{ 0x150046, "TempHUnlock"},
+{ 0x150047, "TempDisposeHandle"},
+{ 0x15005b, "HandToHand"},
+{ 0x15005c, "PtrToXHand"},
+{ 0x15005d, "PtrToHand"},
+{ 0x15005e, "HandAndHand"},
+{ 0x15005f, "PtrAndHand"},
+{ 0x2a0002, "NewWindow"},
+{ 0x2a0003, "GetNewWindow"},
+{ 0x2a0004, "NewCWindow"},
+{ 0x2a0005, "DisposeWindow"},
+{ 0x2a0006, "MacCloseWindow"},
+{ 0x2a0007, "InvalRect"},
+{ 0x2a0008, "InvalRgn"},
+{ 0x2a0009, "ValidRect"},
+{ 0x2a000a, "ValidRgn"},
+{ 0x2a0015, "GetNewCWindow"},
+{ 0x2a0016, "SetWTitle"},
+{ 0x2a0017, "GetWTitle"},
+{ 0x2a0018, "GetWMgrPort"},
+{ 0x2a0019, "GetCWMgrPort"},
+{ 0x2a001a, "SetWRefCon"},
+{ 0x2a001b, "GetWRefCon"},
+{ 0x2a001c, "SelectWindow"},
+{ 0x2a001d, "HideWindow"},
+{ 0x2a001e, "MacShowWindow"},
+{ 0x2a001f, "ShowHide"},
+{ 0x2a0021, "BringToFront"},
+{ 0x2a0022, "SendBehind"},
+{ 0x2a0023, "FrontWindow"},
+{ 0x2a0025, "MacMoveWindow"},
+{ 0x2a0026, "SizeWindow"},
+{ 0x2a0027, "ZoomWindow"},
+{ 0x2a0028, "BeginUpdate"},
+{ 0x2a0029, "EndUpdate"},
+{ 0x2a002d, "MacFindWindow"},
+{ 0x2a002e, "PinRect"},
+{ 0x2a0034, "GetWVariant"},
+{ 0x2a0036, "GetGrayRgn"},
+{ 0x290001, "BitTst"},
+{ 0x290002, "BitSet"},
+{ 0x290003, "BitClr"},
+{ 0x290004, "BitAnd"},
+{ 0x290005, "BitOr"},
+{ 0x290006, "BitXor"},
+{ 0x290007, "BitNot"},
+{ 0x290008, "BitShift"},
+{ 0x29000a, "HiWord"},
+{ 0x29000b, "LoWord"},
+{ 0x0e0001, "GetMouse"},
+{ 0x0e0002, "Button"},
+{ 0x0e0003, "StillDown"},
+{ 0x0e0005, "TickCount"},
+{ 0x0e0007, "GetCaretTime"},
+{ 0x0e0008, "GetEvQHdr"},
+{ 0x0e0009, "GetDblTime"},
+{ 0x0e000a, "SetEventMask"},
+{ 0x0e000b, "PPostEvent"},
+{ 0x0e000c, "GetNextEvent"},
+{ 0x0e000d, "WaitNextEvent"},
+{ 0x0e000e, "EventAvail"},
+{ 0x0e000f, "PostEvent"},
+{ 0x0e0010, "OSEventAvail"},
+{ 0x0e0011, "GetOSEvent"},
+{ 0x0e0012, "FlushEvents"},
+{ 0x0e0014, "SystemTask"},
+{ 0x0e0016, "GetKeys"},
+{ 0x0e0017, "MacGetDoubleClickTime"},
+{ 0x10000, "CallComponent"},
+{ 0x10001, "RegisterComponent"},
+{ 0x10002, "UnregisterComponent"},
+{ 0x10003, "CountComponents"},
+{ 0x10004, "FindNextComponent"},
+{ 0x10005, "GetComponentInfo"},
+{ 0x10006, "GetComponentListModSeed"},
+{ 0x10007, "OpenComponent"},
+{ 0x10008, "CloseComponent"},
+{ 0x10009, "DestroyComponent"},
+{ 0x1000a, "GetComponentInstanceError"},
+{ 0x1000b, "SetComponentInstanceError"},
+{ 0x1000c, "GetComponentInstanceStorage"},
+{ 0x1000d, "SetComponentInstanceStorage"},
+{ 0x1000e, "GetComponentInstanceA5"},
+{ 0x1000f, "SetComponentInstanceA5"},
+{ 0x10010, "GetComponentRefcon"},
+{ 0x10011, "SetComponentRefcon"},
+{ 0x10012, "RegisterComponentResource"},
+{ 0x10013, "CountComponentInstances"},
+{ 0x10014, "RegisterComponentResourceFile"},
+{ 0x10015, "OpenComponentResFile"},
+{ 0x10018, "CloseComponentResFile"},
+{ 0x1001c, "CaptureComponent"},
+{ 0x1001d, "UncaptureComponent"},
+{ 0x1001e, "SetDefaultComponent"},
+{ 0x10020, "ResolveComponentAlias"},
+{ 0x10021, "OpenDefaultComponent"},
+{ 0x10024, "DelegateComponentCall"},
+{ 0x10029, "GetComponentIconSuite"},
+{ 0x1002c, "GetComponentTypeModSeed"},
+{ 0x1002d, "OpenAComponent"},
+{ 0x1002e, "OpenADefaultComponent"},
+{ 0x1002f, "OpenAComponentResFile"},
+{ 0x10035, "GetComponentResource"},
+{ 0x10036, "GetComponentIndString"},
+{ 0x10038, "GetComponentPublicResource"},
+{ 0x10039, "GetComponentPublicResourceList"},
+{ 0x1003a, "GetComponentPublicIndString"},
+{ 0x220003, "FontScript"},
+{ 0x220004, "IntlScript"},
+{ 0x220006, "IsCmdChar"},
+{ 0x220007, "FontToScript"},
+{ 0x220008, "GetScriptManagerVariable"},
+{ 0x22000a, "GetScriptVariable"},
+{ 0x22000c, "CharacterByteType"},
+{ 0x22000d, "CharacterType"},
+{ 0x220018, "CharByte"},
+{ 0x220019, "CharType"},
+{ 0x1f0001, "TextFont"},
+{ 0x1f0002, "TextFace"},
+{ 0x1f0003, "TextMode"},
+{ 0x1f0004, "TextSize"},
+{ 0x1f0005, "SpaceExtra"},
+{ 0x1f0006, "DrawChar"},
+{ 0x1f0007, "DrawString"},
+{ 0x1f0008, "MacDrawText"},
+{ 0x1f0009, "CharWidth"},
+{ 0x1f000a, "StringWidth"},
+{ 0x1f000b, "TextWidth"},
+{ 0x1f000c, "MeasureText"},
+{ 0x1f000d, "GetFontInfo"},
+{ 0x1f000f, "StdText"},
+{ 0x1f0010, "StdTxMeas"},
+{ 0x250003, "SysBeep"},
+{ 0x250004, "SndDoCommand"},
+{ 0x250005, "SndDoImmediate"},
+{ 0x250006, "SndNewChannel"},
+{ 0x250007, "SndDisposeChannel"},
+{ 0x250008, "SndPlay"},
+{ 0x250009, "SndAddModifier"},
+{ 0x25000a, "SndControl"},
+{ 0x25000b, "SndSoundManagerVersion"},
+{ 0x25000f, "SndChannelStatus"},
+{ 0x250010, "SndManagerStatus"},
+{ 0x250015, "Comp3to1"},
+{ 0x250016, "Exp1to3"},
+{ 0x250017, "Comp6to1"},
+{ 0x250018, "Exp1to6"},
+{ 0x25001b, "GetDefaultOutputVolume"},
+{ 0x25001c, "SetDefaultOutputVolume"},
+{ 0x25001d, "GetSoundHeaderOffset"},
+{ 0x25001e, "UnsignedFixedMulDiv"},
+{ 0x25001f, "GetCompressionInfo"},
+{ 0x250020, "SetSoundPreference"},
+{ 0x250021, "GetSoundPreference"},
+{ 0x250022, "SndGetInfo"},
+{ 0x250023, "SndSetInfo"},
+{ 0x250024, "GetSoundOutputInfo"},
+{ 0x250025, "SetSoundOutputInfo"},
+{ 0x250026, "GetCompressionName"},
+{ 0x250027, "SoundConverterOpen"},
+{ 0x250028, "SoundConverterClose"},
+{ 0x250029, "SoundConverterGetBufferSizes"},
+{ 0x25002a, "SoundConverterBeginConversion"},
+{ 0x25002b, "SoundConverterConvertBuffer"},
+{ 0x25002c, "SoundConverterEndConversion"},
+{ 0x25002d, "SoundConverterGetInfo"},
+{ 0x25002e, "SoundConverterSetInfo"},
+{ 0x25002f, "OpenMixerSoundComponent"},
+{ 0x250030, "CloseMixerSoundComponent"},
+{ 0x25003f, "SoundConverterFillBuffer"},
+{ 0x250040, "SoundManagerGetInfo"},
+{ 0x250041, "SoundManagerSetInfo"},
+{ 0x40001, "CompAdd"},
+{ 0x40002, "CompSub"},
+{ 0x40003, "CompNeg"},
+{ 0x40004, "CompShift"},
+{ 0x40005, "CompMul"},
+{ 0x40006, "CompDiv"},
+{ 0x40007, "CompFixMul"},
+{ 0x40008, "CompMulDiv"},
+{ 0x40009, "CompCompare"},
+{ 0x4000a, "FixMulDiv"},
+{ 0x4000b, "FracSinCos"},
+{ 0x4000c, "CompMulDivTrunc"},
+{ 0x4000d, "UnsignedFixMulDiv"},
+{ 0x4000e, "FixExp2"},
+{ 0x4000f, "FixLog2"},
+{ 0x40010, "FixPow"},
+{ 0x40011, "CompSquareRoot"},
+{ 0x40014, "GetMatrixType"},
+{ 0x40015, "SetIdentityMatrix"},
+{ 0x40016, "RotateMatrix"},
+{ 0x40017, "ScaleMatrix"},
+{ 0x40018, "SkewMatrix"},
+{ 0x40019, "TranslateMatrix"},
+{ 0x4001b, "ConcatMatrix"},
+{ 0x4001c, "InverseMatrix"},
+{ 0x4001d, "MapMatrix"},
+{ 0x4001e, "RectMatrix"},
+{ 0x40020, "CopyMatrix"},
+{ 0x40021, "EqualMatrix"},
+{ 0x40022, "TransformFixedPoints"},
+{ 0x40023, "TransformPoints"},
+{ 0x40024, "TransformFixedRect"},
+{ 0x40025, "TransformRect"},
+{ 0x260001, "SFPutFile"},
+{ 0x260002, "CustomPutFile"},
+{ 0x260003, "SFGetFile"},
+{ 0x260004, "SFPPutFile"},
+{ 0x260005, "SFPGetFile"},
+{ 0x260006, "StandardPutFile"},
+{ 0x260007, "StandardGetFile"},
+{ 0x260008, "CustomGetFile"},
+{ 0x180008, "GetDateTime"},
+{ 0x18000c, "DateToSeconds"},
+{ 0x18000d, "SecondsToDate"},
+{ 0x18000e, "DTInstall"},
+{ 0x180011, "Delay"},
+{ 0x180013, "Enqueue"},
+{ 0x180014, "Dequeue"},
+{ 0x18001f, "ReadLocation"},
+{ 0x180022, "InsTime"},
+{ 0x180023, "InsXTime"},
+{ 0x180024, "Microseconds"},
+{ 0x180025, "PrimeTime"},
+{ 0x180026, "RmvTime"},
+{ 0x180027, "MacGetCurrentProcess"},
+{ 0x110001, "Gestalt"},
+{ 0x110004, "NewGestaltValue"},
+{ 0x110005, "ReplaceGestaltValue"},
+{ 0x110006, "SetGestaltValue"},
+{ 0x110007, "DeleteGestaltValue"},
+{ 0x120001, "GetCIcon"},
+{ 0x120002, "PlotCIcon"},
+{ 0x120003, "DisposeCIcon"},
+{ 0x120004, "GetIcon"},
+{ 0x120005, "PlotIcon"},
+{ 0x120006, "PlotIconID"},
+{ 0x120021, "PlotIconHandle"},
+{ 0x120022, "PlotSICNHandle"},
+{ 0x120023, "PlotCIconHandle"},
+{ 0x0b0001, "NewControl"},
+{ 0x0b0003, "DisposeControl"},
+{ 0x0b0004, "KillControls"},
+{ 0x0b0005, "ShowControl"},
+{ 0x0b0006, "HideControl"},
+{ 0x0b0007, "DrawControls"},
+{ 0x0b0008, "Draw1Control"},
+{ 0x0b0009, "UpdateControls"},
+{ 0x0b000a, "HiliteControl"},
+{ 0x0b000b, "TrackControl"},
+{ 0x0b000e, "FindControl"},
+{ 0x0b000f, "MoveControl"},
+{ 0x0b0010, "SizeControl"},
+{ 0x0b0011, "SetControlTitle"},
+{ 0x0b0012, "GetControlTitle"},
+{ 0x0b0013, "GetControlValue"},
+{ 0x0b0014, "SetControlValue"},
+{ 0x0b0015, "GetControlMinimum"},
+{ 0x0b0016, "SetControlMinimum"},
+{ 0x0b0017, "GetControlMaximum"},
+{ 0x0b0018, "SetControlMaximum"},
+{ 0x0b001a, "SetControlAction"},
+{ 0x0b001b, "GetControlAction"},
+{ 0x0b0020, "GetControlComponentInstance"},
+{ 0x0b0021, "GetDialogControlNotificationProc"},
+{ 0x0b0022, "GetControlHandleFromCookie"},
+{ 0x0b0023, "SetControlDefProc"},
+{ 0x0b0024, "SetControlReference"},
+{ 0x0b0025, "GetControlReference"},
+{ 0x280001, "Munger"},
+{ 0x280002, "NewString"},
+{ 0x280004, "GetString"},
+{ 0x280005, "StyledLineBreak"},
+{ 0x280006, "TruncString"},
+{ 0x280007, "TruncText"},
+{ 0x280008, "FindWordBreaks"},
+{ 0x280017, "c2pstr"},
+{ 0x280018, "p2cstr"},
+{ 0x280019, "c2pstrcpy"},
+{ 0x28001a, "p2cstrcpy"},
+{ 0x28001c, "IUCompPString"},
+{ 0x28001d, "IUDateString"},
+{ 0x28001e, "IUTimeString"},
+{ 0x28001f, "IUEqualString"},
+{ 0x280020, "IUMagIDString"},
+{ 0x280021, "IUMagString"},
+{ 0x280022, "EqualString"},
+{ 0x280023, "RelString"},
+{ 0x280024, "NumToString"},
+{ 0x280025, "StringToNum"},
+{ 0x280028, "ExtendedToString"},
+{ 0x28002a, "IUMagIDPString"},
+{ 0x230006, "ExitToShell"},
+{ 0x0f0007, "PBReadSync"},
+{ 0x0f0008, "PBReadAsync"},
+{ 0x0f000a, "PBWriteSync"},
+{ 0x0f000b, "PBWriteAsync"},
+{ 0x0f000d, "PBGetVInfoSync"},
+{ 0x0f0021, "PBGetFInfoSync"},
+{ 0x0f0023, "PBSetFInfoSync"},
+{ 0x0f002d, "PBGetEOFSync"},
+{ 0x0f002f, "PBSetEOFSync"},
+{ 0x0f0035, "PBFlushFileSync"},
+{ 0x0f003e, "SetVol"},
+{ 0x0f0041, "FlushVol"},
+{ 0x0f0046, "FSClose"},
+{ 0x0f0047, "FSRead"},
+{ 0x0f0048, "FSWrite"},
+{ 0x0f004a, "GetFInfo"},
+{ 0x0f004b, "GetVol"},
+{ 0x0f004d, "FSDelete"},
+{ 0x0f004f, "Rename"},
+{ 0x0f0054, "GetEOF"},
+{ 0x0f0055, "SetEOF"},
+{ 0x0f0056, "GetFPos"},
+{ 0x0f0057, "SetFPos"},
+{ 0x0f0067, "PBGetFCBInfoSync"},
+{ 0x0f0069, "PBGetCatInfoSync"},
+{ 0x0f006d, "PBAllocContigSync"},
+{ 0x0f0075, "PBHGetVInfoSync"},
+{ 0x0f0077, "PBHOpenSync"},
+{ 0x0f0079, "PBHOpenRFSync"},
+{ 0x0f007b, "PBHOpenDFSync"},
+{ 0x0f007d, "PBHCreateSync"},
+{ 0x0f00a2, "PBHGetVolParmsSync"},
+{ 0x0f00e2, "FSMakeFSSpec"},
+{ 0x0f00e3, "FSpOpenDF"},
+{ 0x0f00e4, "FSpOpenRF"},
+{ 0x0f00e5, "FSpCreate"},
+{ 0x0f00e7, "FSpDelete"},
+{ 0x0f00e8, "FSpGetFInfo"},
+{ 0x0f00ec, "FSpRename"},
+{ 0x100001, "FixRatio"},
+{ 0x100002, "FixMul"},
+{ 0x100003, "FixRound"},
+{ 0x100004, "Fix2Frac"},
+{ 0x100005, "Fix2Long"},
+{ 0x100006, "Long2Fix"},
+{ 0x100007, "Frac2Fix"},
+{ 0x100008, "FracMul"},
+{ 0x100009, "FixDiv"},
+{ 0x10000a, "FracDiv"},
+{ 0x10000b, "FracSqrt"},
+{ 0x10000c, "FracSin"},
+{ 0x10000d, "FracCos"},
+{ 0x10000e, "FixATan2"},
+{ 0x10000f, "RefFrac2X"},
+{ 0x100010, "RefFix2X"},
+{ 0x100011, "RefX2Fix"},
+{ 0x100012, "RefX2Frac"},
+{ 0x80001, "NewAlias"},
+{ 0x80002, "NewAliasMinimal"},
+{ 0x80003, "NewAliasMinimalFromFullPath"},
+{ 0x80004, "ResolveAlias"},
+{ 0x80005, "GetAliasInfo"},
+{ 0x80006, "ResolveAliasFile"},
+{ 0x80008, "UpdateAlias"},
+{ 0x80009, "MatchAlias"},
+{ 0x2b0002, "GetFontName"},
+{ 0x2b0003, "RealFont"},
+{ 0x2b0004, "GetFNum"},
+{ 0x130001, "LNew"},
+{ 0x130002, "LDispose"},
+{ 0x130004, "LAddRow"},
+{ 0x130006, "LDelRow"},
+{ 0x130007, "LGetSelect"},
+{ 0x130008, "LLastClick"},
+{ 0x130009, "LNextCell"},
+{ 0x13000a, "LSearch"},
+{ 0x13000c, "LSetDrawingMode"},
+{ 0x13000d, "LScroll"},
+{ 0x13000e, "LAutoScroll"},
+{ 0x13000f, "LUpdate"},
+{ 0x130010, "LActivate"},
+{ 0x130012, "LClick"},
+{ 0x130013, "LAddToCell"},
+{ 0x130014, "LClrCell"},
+{ 0x130015, "LGetCell"},
+{ 0x130016, "LRect"},
+{ 0x130017, "LSetCell"},
+{ 0x130018, "LSetSelect"},
+{ 0x130019, "LDraw"},
+{ 0x13001a, "LGetCellDataLocation"},
+{ 0x13001c, "LSetNotificationCallback"},
+{ 0x13001d, "LSetLDEF"},
+{ 0x13001e, "GetListVisibleBounds"},
+{ 0x210001, "InfoScrap"},
+{ 0x210002, "UnloadScrap"},
+{ 0x210003, "LoadScrap"},
+{ 0x210004, "GetScrap"},
+{ 0x210005, "ZeroScrap"},
+{ 0x210006, "PutScrap"},
+{ 0x14000b, "LMGetTheZone"},
+{ 0x140019, "LMGetTicks"},
+{ 0x14004b, "LMGetMemErr"},
+{ 0x14005d, "LMGetSysZone"},
+{ 0x14006b, "LMGetDoubleTime"},
+{ 0x14008d, "LMGetScrnBase"},
+{ 0x14008f, "LMGetMainDevice"},
+{ 0x140091, "LMGetDeviceList"},
+{ 0x1400bf, "LMGetWindowList"},
+{ 0x1400c2, "LMGetPaintWhite"},
+{ 0x1400c3, "LMSetPaintWhite"},
+{ 0x1400c6, "LMGetGrayRgn"},
+{ 0x1400f5, "LMGetResLoad"},
+{ 0x1400f7, "LMGetResErr"},
+{ 0x140137, "LMGetTheGDevice"},
+{ 0x240001, "SPBVersion"},
+{ 0x240006, "SPBGetIndexedDevice"},
+{ 0x240007, "SPBOpenDevice"},
+{ 0x240008, "SPBCloseDevice"},
+{ 0x240009, "SPBRecord"},
+{ 0x24000b, "SPBMillisecondsToBytes"},
+{ 0x24000c, "SPBBytesToMilliseconds"},
+{ 0x24000d, "SetupSndHeader"},
+{ 0x24000e, "SetupAIFFHeader"},
+{ 0x24000f, "ParseAIFFHeader"},
+{ 0x240010, "ParseSndHeader"},
+{ 0x240011, "SPBPauseRecording"},
+{ 0x240012, "SPBStopRecording"},
+{ 0x240013, "SPBGetDeviceInfo"},
+{ 0x240014, "SPBSetDeviceInfo"},
+{ 0x240015, "SPBResumeRecording"},
+{ 0x240016, "SPBGetRecordingStatus"},
+{ 0x1b0003, "PrOpen"},
+{ 0x1b0004, "PrClose"},
+{ 0x1b0005, "PrintDefault"},
+{ 0x1b0006, "PrValidate"},
+{ 0x1b0007, "PrStlDialog"},
+{ 0x1b0008, "PrJobDialog"},
+{ 0x1b0009, "PrStlInit"},
+{ 0x1b000a, "PrJobInit"},
+{ 0x1b000b, "PrJobMerge"},
+{ 0x1b000c, "PrDlgMain"},
+{ 0x1b000d, "PrOpenDoc"},
+{ 0x1b000e, "PrCloseDoc"},
+{ 0x1b000f, "PrOpenPage"},
+{ 0x1b0010, "PrClosePage"},
+{ 0x1b0011, "PrPicFile"},
+{ 0x1b0012, "PrError"},
+{ 0x1b0013, "PrSetError"},
+{ 0x1b0014, "PrGeneral"},
+{ 0x270002, "TENew"},
+{ 0x270003, "TEDispose"},
+{ 0x270004, "TESetText"},
+{ 0x270005, "TEGetText"},
+{ 0x270006, "TEIdle"},
+{ 0x270007, "TESetSelect"},
+{ 0x270008, "TEActivate"},
+{ 0x270009, "TEDeactivate"},
+{ 0x27000e, "TEDelete"},
+{ 0x27000f, "TEInsert"},
+{ 0x270010, "TESetAlignment"},
+{ 0x270011, "TEUpdate"},
+{ 0x270012, "TETextBox"},
+{ 0x270013, "TEScroll"},
+{ 0x270014, "TESelView"},
+{ 0x270015, "TEPinScroll"},
+{ 0x270016, "TEAutoView"},
+{ 0x270017, "TECalText"},
+{ 0x270018, "TEGetOffset"},
+{ 0x270019, "TEGetPoint"},
+{ 0x27001b, "TEStyleNew"},
+{ 0x27001c, "TESetStyleHandle"},
+{ 0x27001d, "TEGetStyleHandle"},
+{ 0x27001e, "TEGetStyle"},
+{ 0x27001f, "TEStylePaste"},
+{ 0x270020, "TESetStyle"},
+{ 0x270021, "TEReplaceStyle"},
+{ 0x270022, "TEGetStyleScrapHandle"},
+{ 0x270023, "TEStyleInsert"},
+{ 0x270024, "TEGetHeight"},
+{ 0x270025, "TEContinuousStyle"},
+{ 0x270026, "TEUseStyleScrap"},
+{ 0x270028, "TENumStyles"},
+{ 0x270029, "TEFeatureFlag"},
+{ 0,NULL } };

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loader/wrapper.S	Sun Nov 24 21:45:23 2002 +0000
@@ -0,0 +1,83 @@
+.section .data
+.globl caller_return
+caller_return:
+	.long 0
+.globl report_entry
+report_entry:
+	.long null_call
+.globl report_ret
+report_ret:	
+	.long null_call
+.global wrapper_target
+wrapper_target:	
+	.long null_call
+
+.section .text
+.globl null_call
+	.type null_call, @function
+	.align 16,0x90
+null_call:
+	ret
+.globl wrapper
+	.type wrapper, @function
+	.align 16,0x90
+wrapper:
+	pusha			# store registers (EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI) 
+	pushf			# store flags
+	
+	push %ebp		# set up a stack frame 
+	movl %esp, %ebp
+
+	leal 4(%ebp), %eax	# push flags addr
+	push %eax
+	leal 8(%ebp), %eax	# push registers addr
+	push %eax
+	
+	leal 40(%ebp), %edx	
+	movl (%ebp), %eax
+	subl %edx, %eax
+	push %eax
+	push %edx
+	
+	call *report_entry	# report entry
+	
+	test %eax, %eax
+	jnz .Ldone
+
+	leave			# restore %esp, %ebp
+	popf			# restore flags
+	popa			# restore registers
+	
+	popl caller_return	# switch return addresses
+	pushl $.Lwrapper_return 
+	
+	jmp *wrapper_target	# wrapper_target should return at .Lwrapper_return
+
+	.align 16, 0x90
+.Lwrapper_return:	
+	pushl caller_return	# restore the original return address
+	pusha			# more for reference sake here
+	pushf
+	
+	push %ebp		# set up a stack frame
+	movl %esp, %ebp
+
+	leal 4(%ebp), %eax	# push flags addr
+	push %eax
+	leal 8(%ebp), %eax	# push registers addr
+	push %eax
+
+	leal 40(%ebp), %edx	# push stack top address (relative to our entry)
+	movl (%ebp), %eax
+	subl %edx, %eax		# calculate difference between entry and previous frame
+	push %eax
+	push %edx
+
+	call *report_ret	# report the return information (same args)
+.Ldone:	
+
+	leave
+	popf
+	popa
+	ret
+	
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loader/wrapper.h	Sun Nov 24 21:45:23 2002 +0000
@@ -0,0 +1,20 @@
+#ifndef _WRAPPER_H
+#define _WRAPPER_H
+
+#include <sys/types.h>
+
+typedef struct {
+  u_int32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
+} reg386_t;
+
+typedef int (*wrapper_func_t)(void *stack_base, int stack_size, reg386_t *reg,  u_int32_t *flags);
+
+extern wrapper_func_t report_entry, report_ret;
+
+extern void (*wrapper_target)(void);
+
+extern int wrapper(void);
+extern int null_call(void);
+
+#endif /* _WRAPPER_H */
+