#ifndef __MWERKS__
#include "SysHeaders.h"
#endif

#include "ext_mess.h"

typedef long (*fptr)();
typedef void *(*methodptr)();
typedef short (*fretint)();	/* kludge to cast to function returning int */
#ifdef __MOTO__
typedef short (*eachdomethod)();
#else
typedef short (*eachdomethod)(...);
#endif
#ifdef __MOTO__
typedef long (*exprmethod)();
#else
typedef long (*exprmethod)(...);
#endif

#define clock_free freeobject
#define binbuf_free freeobject
#define wind_free freeobject

#ifdef powerc
#include "ext_proto.h"

#else
#pragma d0_pointers on
#include "ext_support.h"   /* defines things like "f_setup" */

#define setup (*(FNS[f_setup]))
#define addmess (*(FNS[f_addmess]))
#define addbang(fn) ((*(FNS[f_addbang]))(fn))
#define addint(fn) ((*(FNS[f_addint]))(fn))
#define addfloat(fn) ((*(FNS[f_addfloat]))(fn))
#define addinx(fn,in) ((*(FNS[f_addinx]))(fn,in))
#define addftx(fn,in) ((*(FNS[f_addftx]))(fn,in))
#define newobject(cl)	((void *)((*(FNS[f_newobject]))(cl)))
#define getbytes(sz)	((void *)((*(FNS[f_getbytes]))((short)sz)))
#define freebytes(ptr,sz) ((void *)((*(FNS[f_freebytes]))(ptr,sz)))
#define intin(ob,in) ((void *)((*(FNS[f_intin]))(ob,in)))
#define floatin(ob,in) (void *)((*(FNS[f_floatin]))(ob,in))
#define outlet_new(ob,ty)	((void *)((*(FNS[f_outlet_new]))(ob,ty)))
#define bangout(ob)	((void *)((*(FNS[f_bangout]))(ob)))
#define intout(ob)	((void *)((*(FNS[f_intout]))(ob)))
#define floatout(ob)	((void *)((*(FNS[f_floatout]))(ob)))
#define listout(ob)	((void *)((*(FNS[f_listout]))(ob)))
#define outlet_bang(ob) ((void *)((*(FNS[f_outlet_bang]))(ob)))
#define outlet_int(ob,n) ((void *)((*(FNS[f_outlet_int]))(ob,n)))
#define outlet_float(ob,f) ((void *)((*(FNS[f_outlet_float]))(ob,f)))
#define outlet_list(ob,sy,ac,av) ((void *)((*(FNS[f_outlet_list]))(ob,sy,ac,av)))
#define outlet_anything(ob,sy,ac,av) ((void *)((*(FNS[f_outlet_anything]))(ob,sy,ac,av)))
#define gensym(st) ((struct symbol *)((*(FNS[f_gensym]))(st)))
#define clock_new(ob,fn)	((void *)((*(FNS[f_clock]))(ob,fn)))
#define clock_set(ck,at) ((*(FNS[f_clock_set]))(ck,at))
#define clock_delay(ck,dt) ((*(FNS[f_clock_delay]))(ck,dt))
#define clock_unset(ck) ((*(FNS[f_clock_unset]))(ck))
#define gettime() ((long)((*(FNS[f_gettime]))()))
#define qelem_new(ob,fn) ((void *)((*(FNS[f_qelem]))(ob,fn)))
#define qelem_set(qe) ((*(FNS[f_qelem_set]))(qe))
#define qelem_unset(qe) ((*(FNS[f_qelem_unset]))(qe))
#define qelem_free(qe) ((*(FNS[f_qelem_free]))(qe))
#define newhandle(sz) ((char **)((*(FNS[f_newhandle]))(sz)))
#define disposhandle(ha) ((*(FNS[f_disposhandle]))(ha))
#define growhandle(ha,sz) ((short)((*(FNS[f_growhandle]))(ha,sz)))
#define post (*(FNS[f_post]))
#define wind_new(as,x1,y1,x2,y2,fl) \
	((void *)((*(FNS[f_wind]))(as,x1,y1,x2,y2,fl)))
#define wind_vis(wi) ((void)((*(FNS[f_wind_vis]))(wi)))
#define wind_invis(wi) ((void)((*(FNS[f_wind_invis]))(wi)))
#define wind_setport(wi) ((GrafPort *)((*(FNS[f_wind_setport]))(wi)))
#define wind_settitle(wi,ti,bk) ((void)((*(FNS[f_wind_settitle]))(wi,ti,bk)))
#define wind_dirty(wi) ((void)((*(FNS[f_wind_dirty]))(wi)))
#define wind_setsmax(wi,xm,ym) ((void)((*(FNS[f_wind_setsmax]))(wi,xm,ym)))
#define wind_setsval(wi,xv,yv) ((void)((*(FNS[f_wind_setsval]))(wi,xv,yv)))
#define wind_drag(fn,ag,pt) ((void)((*(FNS[f_wind_drag]))(fn,ag,pt)))
#define wind_defaultscroll(wi,pt,ps) ((short)((*(FNS[f_wind_defaultscroll]))(wi,pt,ps)))
#define defvolume() ((short)((*(FNS[f_defvolume]))()))
#define binbuf_new() ((void *)((*(FNS[f_binbuf_new]))()))
#define binbuf_insert(bb,ig,ac,av) ((*(FNS[f_binbuf_insert]))(bb,ig,ac,av))
#define binbuf_vinsert (*(FNS[f_binbuf_vinsert]))
#define binbuf_eval(bb,ac,av,to) ((void *)((*(FNS[f_binbuf_eval]))(bb,ac,av,to)))
#define binbuf_getatom(bb,p1,p2,at) ((short)((*(FNS[f_binbuf_getatom]))(bb,p1,p2,at)))
#define binbuf_text(bb,ht,sz) ((short)((*(FNS[f_binbuf_text]))(bb,ht,sz)))
#define binbuf_totext(bb,ht,sz) ((void)((*(FNS[f_binbuf_totext]))(bb,ht,sz)))
#define sprintf (*(fretint)(FNS[f_sprintf]))
#define sscanf (*(fretint)(FNS[f_sscanf]))
#define t_cpytext() ((void)((*(FNS[f_cpytext]))()))
#define typedmess(ob,ms,ac,av) ((void)((*(FNS[f_typedmess]))(ob,ms,ac,av)))
#define binbuf_set(bb,sy,ac,av) ((void)((*(FNS[f_binbuf_set]))(bb,sy,ac,av)))
#define binbuf_append(bb,sy,ac,av) ((void)((*(FNS[f_binbuf_append]))(bb,sy,ac,av)))
#define	patcher_setport(pa)	((GrafPort *)((*(FNS[f_patcher_setport]))(pa)))
#define box_new(bx,pa,fl,x1,y1,x2,y2) ((void *)((*(FNS[f_box_new]))(bx,pa,fl,x1,y1,x2,y2)))
#define box_free(bx) ((void)((*(FNS[f_box_free]))(bx)))
#define box_ready(bx) ((void)((*(FNS[f_box_ready]))(bx)))
#define patchbox(pa,fl,ac,av,wi) ((void *)((*(FNS[f_patchbox]))(pa,fl,ac,av,wi)))
#define lockout_set(lo) ((short)((*(FNS[f_lockout_set]))(lo)))
#define patcher_dirty(pa) (((*(FNS[f_patcher_dirty]))(pa)))
#define patcher_selectbox(pa,bx) (((*(FNS[f_patcher_selectbox]))(pa,bx)))
#define patcher_deselectbox(pa,bx) (((*(FNS[f_patcher_deselectbox]))(pa,bx)))
#define drawstr(st) (((*(FNS[f_drawstr]))(st)))
#define binbuf_savebox (*(FNS[f_binbuf_savebox]))
#define textbox(p,f,c,v) (((void *)(*(FNS[f_textbox]))(p,f,c,v)))
#define box_ownerlocked(x) ((short)((*(FNS[f_box_ownerlocked]))(x)))
#define box_size(x,y,z) (((*(FNS[f_box_size]))(x,y,z)))
#define rescopy(a,b)  (((*(FNS[f_rescopy]))(a,b)))
#define inlet_new(ob,in) ((void *)((*(FNS[f_inlet_new]))(ob,in)))
#define wind_helpfolder() ((char *)((*(FNS[f_wind_helpfolder]))()))
#define wind_noworrymove() (((*(FNS[f_wind_noworrymove]))()))
#define wind_setundo(x,y) (((*(FNS[f_wind_setundo]))(x,y)))
#define getschedtime() ((long)((*(FNS[f_getschedtime]))()))
#define getexttime() ((long)((*(FNS[f_getexttime]))()))
#define clock_xdelay (*(FNS[f_clock_xdelay]))
#define clock_xset (*(FNS[f_clock_xset]))
#define clock_xunset (*(FNS[f_clock_xunset]))
#define clock_getextfmt() (((*(FNS[f_clock_getextfmt]))()))
#define isr() (((*(FNS[f_isr]))()))
#define maxversion()  ((unsigned short)((*(FNS[f_maxversion]))()))
#define table_get(a,b,c)  (((*(FNS[f_table_get]))(a,b,c)))
#define table_dirty()  (((*(FNS[f_table_dirty]))()))
#define binbuf_read(a, b, c, d)  (((*(FNS[f_binbuf_read]))(a, b, c, d)))
#define binbuf_write(a, b, c, d)  (((*(FNS[f_binbuf_write]))(a, b, c, d)))
#define ouchstring  (*(FNS[f_ouchstring]))
#define palette() ((void *)((*(FNS[f_palette]))()))
#define ispatcher(x) ((*(FNS[f_ispatcher]))(x))
#define isnewex(x) ((*(FNS[f_isnewex]))(x))
#define newex_knows(x,s) ((*(FNS[f_newex_knows]))(x,s))
#define expr_new(a,v,r) ((void *)((*(FNS[f_expr_new]))(a,v,r)))
#define expr_eval(a,b,c,d) ((void *)((*(FNS[f_expr_eval]))(a,b,c,d)))
#define freeobject(x) ((*(FNS[f_freeobject]))(x))
#define error (*(FNS[f_error]))
#define preset_store (*(FNS[f_preset_store]))
#define preset_set(x,y) ((*(FNS[f_preset_set]))(x,y))
#define preset_int(x,y) ((*(FNS[f_preset_int]))(x,y))
#define colorinfo(x) ((void *)((*(FNS[f_colorinfo]))(x)))
#define finder_addclass(x,y) ((*(FNS[f_finder_addclass]))(x,y))
#define newinstance(x, y, z) ((void *)((*(FNS[f_newinstance]))(x, y, z)))
#define getfn(x, y) ((method)((*(FNS[f_getfn]))(x, y)))
#define egetfn(x, y) ((method)((*(FNS[f_egetfn]))(x, y)))
#define zgetfn(x, y) ((method)((*(FNS[f_zgetfn]))(x, y)))
#define ed_new(a) ((void *)((*(FNS[f_ed_new]))(a)))
#define ed_vis(x) ((*(FNS[f_ed_vis]))(x))
#define ed_free(x) ((*(FNS[f_ed_free]))(x))
#define ed_settext(x,y,z) ((*(FNS[f_ed_settext]))(x,y,z))
#define readatom(x,y,z,w,v) ((*(FNS[f_readatom]))(x,y,z,w,v))
#define open_dialog(x,y,z,w,v) ((*(FNS[f_open_dialog]))(x,y,z,w,v))
#define saveas_dialog(x,y,z) ((*(FNS[f_saveas_dialog]))(x,y,z))
#define locatefile(x,y,z) ((*(FNS[f_locatefile]))(x,y,z))
#define inlet4(w,y,z,x)	((void *)((*(FNS[f_inlet4]))(w,y,z,x)))
#define inlet_to(x,y) ((*(FNS[f_inlet_to]))(x,y))
#define patcher_okclose(x,y) ((*(FNS[f_patcher_okclose]))(x,y))
#define advise (*(FNS[f_advise]))
#define qelem_front(x) ((*(FNS[f_qelem_front]))(x))
#define evnum_incr() ((void *)((*(FNS[f_evnum_incr]))()))
#define evnum_get() ((long)((*(FNS[f_evnum_get]))()))
#define patcher_eachdo(x,y) ((*(FNS[f_patcher_eachdo]))(x,y))
#define box_nodraw(x) ((*(FNS[f_box_nodraw]))(x))
#define wind_setcursor(x) ((*(FNS[f_wind_setcursor]))(x))
#define num_new(t,l,b,r,d,i,f,m1,m2,v,o,s) ((void *)((*(FNS[f_num_new]))(t,l,b,r,d,i,f,m1,m2,v,o,s)))
#define num_draw(x) ((*(FNS[f_num_draw]))(x))
#define num_hilite(x,y) ((*(FNS[f_num_hilite]))(x,y))
#define num_test(x,y) ((*(FNS[f_num_test]))(x,y))
#define num_track(n,s,t,a) ((*(FNS[f_num_track]))(n,s,t,a))
#define num_setvalue(x,y,z) ((*(FNS[f_num_setvalue]))(x,y,z))
#define proxy_new(x,y,z) ((void *)((*(FNS[f_proxy_new]))(x,y,z)))
#define gwind_new(a,b,c,d,e,f,g) ((void *)((*(FNS[f_gwind_new]))(a,b,c,d,e,f,g)))
#define gwind_offscreen(x) ((*(FNS[f_gwind_offscreen]))(x))
#define gwind_setport(x) ((GrafPort *)((*(FNS[f_gwind_setport]))(x)))
#define	gwind_get(x) ((void *)((*(FNS[f_gwind_get]))(x)))
#define off_new(x) ((void *)((*(FNS[f_off_new]))(x)))
#define off_free(x) ((*(FNS[f_off_free]))(x))
#define sprite_new(a,b,c,d,e) ((void *)((*(FNS[f_sprite_new]))(a,b,c,d,e)))
#define sprite_moveto(x,y,z) ((*(FNS[f_sprite_moveto]))(x,y,z))
#define off_maxrect(a,b,c,d) ((*(FNS[f_off_maxrect]))(a,b,c,d))
#define sprite_move(x,y,z) ((*(FNS[f_sprite_moveto]))(x,y,z))
#define sprite_redraw(a,b,c,d,e) ((*(FNS[f_sprite_redraw]))(a,b,c,d,e))
#define off_copy(x) ((*(FNS[f_off_copy]))(x))
#define sprite_draw(x) ((*(FNS[f_sprite_draw]))(x))
#define sprite_erase(x) ((*(FNS[f_sprite_erase]))(x))
#define sprite_rect(x,y,a,b) ((*(FNS[f_sprite_rect]))(x,y,a,b))
#define off_tooff(x,y,z,a) ((*(FNS[f_off_tooff]))(x,y,z,a))
#define off_size(x) ((*(FNS[f_off_size]))(x))
#define off_copyrect(x,y) ((*(FNS[f_off_copyrect]))(x,y))
#define alias(x) ((*(FNS[f_alias]))(x))
#define locatefiletype(x,y,z,a) ((*FNS[f_locatefiletype]))(x,y,z,a)
#define midiinfo(x)	((*(FNS[f_midiinfo]))(x))
#define serialno() ((long)((*(FNS[f_serialno]))()))
#define postatom(x)	((*(FNS[f_postatom]))(x))
#define sprite_newpriority(x,y) ((*(FNS[f_sprite_newpriority]))(x,y))
#define assist_string (*(FNS[f_assist_string]))
#define box_erase(x) ((*(FNS[f_box_erase]))(x))	
#define box_redraw(x) ((*(FNS[f_box_erase]))(x))	
#define defer(x,y,z,a,b) ((*(FNS[f_defer]))(x,y,z,a,b))	
#define defer_low(x,y,z,a,b) ((*(FNS[f_defer_low]))(x,y,z,a,b))	
#define callback_new(x,y,z,b,a) ((void *)((*(FNS[f_callback_new]))(x,y,z,b,a)))
#define locatefilelist(x,y,z,b,a) ((void *)((*(FNS[f_locatefilelist]))(x,y,z,b,a)))
#define resnamecopy(a,b) ((*(FNS[f_resnamecopy]))(a,b))
#define binbuf_delete(a,b,c,d,e) ((*(FNS[f_binbuf_delete]))(a,b,c,d,e))
#define force_install(x) ((*(FNS[f_force_install]))(x))
#define sched_suspend() ((*(FNS[f_sched_suspend]))())
#define sched_resume() ((*(FNS[f_sched_resume]))())
#define readtohandle(n,v,h,s) ((*(FNS[f_readtohandle]))(n,v,h,s))
#define fileload(n,v) ((void *)((*(FNS[f_fileload]))(n,v)))
#define intload(n,v,s,c,a,e) ((void *)((*(FNS[f_intload]))(n,v,s,c,a,e)))
#define box_color(b) ((*(FNS[f_box_color]))(b))	
#define box_getcolor(b,i,c) ((*(FNS[f_box_getcolor]))(b,i,c))
#define assist_drawstr(p,s) ((*(FNS[f_assist_drawstr]))(p,s))
#define schedule(o,f,w,s,c,v) ((*(FNS[f_schedule]))(o,f,w,s,c,v))
#define usecolor(b) ((*(FNS[f_usecolor]))(b))
#define palette_getcolor(b,i,c) ((*(FNS[f_palette_getcolor]))(b,i,c))

#define fopen(x,y) ((*(FNS[f_f_fopen]))(x,y))
#define fclose(x,y) ((*(FNS[f_fclose]))(x,y))
#define fprintf(x,y) ((*(FNS[f_fprintf]))(x,y))
#define fscanf(x,y) ((*(FNS[f_fscanf]))(x,y))
#define fseek(x,y) ((*(FNS[f_fseek]))(x,y))
#define message_register(x,y,z,a) ((*(FNS[f_message_register]))(x,y,z,a))
#define editor_register(dt,en,nf,mn,uf) ((*(FNS[f_editor_register]))(dt,en,nf,mn,uf))
#define atombuf_new(av,ac) ((void *)((*(FNS[f_atombuf_new]))(av,ac)))
#define atombuf_free(a) ((*(FNS[f_atombuf_free]))(a))
#define atombuf_text(x,sh,si) ((*(FNS[f_atombuf_text]))(x,sh,si))
#define event_new(ev,tr,dt,ms,ed,la,st,du,fl,bo) ((*(FNS[f_event_new]))(ev,tr,dt,ms,ed,la,st,du,fl,bo))
#define event_box(ev,to,bo) ((*(FNS[f_event_box]))(ev,to,bo))
#define message_patcherRegister(x,y,z,a,b) ((*(FNS[f_message_patcherRegister]))(x,y,z,a,b))
#define bf_singlefast(h,hsize,argc,argv) ((*(FNS[f_bf_singlefast]))(h,hsize,argc,argv))
#define open_promptset(s) ((*(FNS[f_open_promptset]))(s))
#define saveas_promptset(s) ((*(FNS[f_saveas_promptset]))(s))
#define stringload(s) ((void *)((*(FNS[f_stringload]))(s)))
#define resource_install(name,rsrc) ((*(FNS[f_resource_install]))(name,rsrc))
#define toolfile_new(name,vol,type) ((void *)((*(FNS[f_toolfile_new]))(name,vol,type)))
#define toolfile_fread(t,b,n) ((*(FNS[f_toolfile_fread]))(t,b,n))
#define toolfile_fwrite(t,b,n) ((*(FNS[f_toolfile_fwrite]))(t,b,n))
#define wind_filename(x,f,v,b) ((*(FNS[f_wind_filename]))(x,f,v,b))
#define wind_close(x) ((*(FNS[f_wind_close]))(x))
#define wind_nocancel() ((*(FNS[f_wind_nocancel]))())
#define wind_inhscroll(x,pt) ((*(FNS[f_wind_inhscroll]))(x,pt))
#define wind_setbin(x,way) ((*(FNS[f_wind_setbin]))(x,way))
#define class_noinlet(c) ((*(FNS[f_class_noinlet]))(c))
#define expr_install(fu,bu,ar)  ((*(FNS[f_expr_install]))(fu,bu,ar))
#define dialog_poll(ds,de,em)  ((*(FNS[f_dialog_poll]))(ds,de,em))
#define message_unregister(na,sc,to,on,tr)  ((*(FNS[f_message_unregister]))(na,sc,to,on,tr))
#define message_patcherUnregister(na,sc,to,on,pa)  ((*(FNS[f_message_patcherUnregister]))(na,sc,to,on,pa))
#define connection_client(cl,na,ca,tr) ((void *)(*(FNS[f_connection_client]))(cl,na,ca,tr))
#define connection_server(ob,na) ((*(FNS[f_connection_server]))(ob,na))
#define connection_send(se,na,me,ar) ((*(FNS[f_connection_send]))(se,na,me,ar))
#define connection_delete(ob,na) ((*(FNS[f_connection_delete]))(ob,na))
#define toolfile_getc(tf) ((*(FNS[f_toolfile_getc]))(tf))
#define debug_printf (*(FNS[f_debug_printf]))
#define event_spool(ev)	((*(FNS[f_event_spool]))(ev))
#define event_schedule(ev,fn,de,ar,dl,fl) ((*(FNS[f_event_schedule]))(ev,fn,de,ar,dl,fl))
#define track_clipBegin(tr,rc) ((*(FNS[f_track_clipBegin]))(tr,rc))
#define track_clipEnd(tr) ((*(FNS[f_track_clipEnd]))(tr))
#define event_offsetRect(ev) ((*(FNS[f_event_offsetRect]))(ev))
#define track_eraseDragTime(tr) ((*(FNS[f_track_eraseDragTime]))(tr))
#define track_drawDragParam(tr,bu) ((*(FNS[f_track_drawDragParam]))(tr,bu))
#define track_drawDragTime(tr,a,b) ((*(FNS[f_track_drawDragTime]))(tr,a,b))
#define track_drawTime(tr,ti) ((*(FNS[f_track_drawTime]))(tr,ti))
#define track_pixToMS(tr,pi) ((long)(*(FNS[f_track_pixToMS]))(tr,pi))
#define track_MSToPix(tr,ms) ((*(FNS[f_track_MSToPix]))(tr,ms))
#define track_posToMS(tr,pi) ((long)(*(FNS[f_track_posToMS]))(tr,pi))
#define track_MSToPos(tr,ms) ((*(FNS[f_track_MSToPos]))(tr,ms))
#define track_setport(tr) ((GrafPort *)(*(FNS[f_track_setport]))(tr))
#define event_clock(ev) ((void *)(*(FNS[f_event_clock]))(ev))
#define event_avoidRect(ev,id) ((void *)(*(FNS[f_event_avoidRect]))(ev,id))
#define event_save(ev,at) ((*(FNS[f_event_save]))(ev,at))
#define tabfromhandle(ha,sz) ((void *)(*(FNS[f_tabfromhandle]))(ha,sz))
#define stdlist(ob,sy,ac,av) ((void *)(*(FNS[f_stdlist]))(ob,sy,ac,av))
#define setclock_delay(sc,cl,dl) ((*(FNS[f_setclock_delay]))(sc,cl,dl))
#define setclock_unset(sc,cl) ((*(FNS[f_setclock_unset]))(sc,cl))
#define setclock_gettime(sc) ((long)(*(FNS[f_setclock_gettime]))(sc))
#define patcher_avoidrect(pa,rc,id) ((void *)(*(FNS[f_patcher_avoidrect]))(pa,rc,id))
#define collective_load(na,vo,ac,av) ((short)(*(FNS[f_collective_load]))(na,vo,ac,av))
#define assist_queue(x,f) ((*(FNS[f_assist_queue]))(x,f))
#define clock_fdelay(x,f)  ((*(FNS[f_clock_fdelay]))(x,f))
#define setclock_fdelay(x,c,f)  ((*(FNS[f_setclock_fdelay]))(x,c,f))
#define clock_getftime(t)  ((*(FNS[f_clock_getftime]))(t))
#define setclock_getftime(x,t)  ((*(FNS[f_setclock_getftime]))(x,t))
#define wind_syswind(w) ((void *)(*(FNS[f_wind_syswind]))(w))

#endif