shithub: purgatorio

Download patch

ref: d21de87db1e6068d35f66da7411a98231c361a70
parent: e17484e9d82ce7db8472e6abfa71144ddc184ce4
author: henesy <devnull@localhost>
date: Sun Nov 4 20:44:49 EST 2018 

fix missing elements and tweak scripts; add makestubs to ease install process

diff: cannot open b/opt/misc/appl//null: file does not exist: 'b/opt/misc/appl//null' diff: cannot open b/opt/misc/dis//null: file does not exist: 'b/opt/misc/dis//null' diff: cannot open b/opt/misc//null: file does not exist: 'b/opt/misc//null' diff: cannot open b/opt/mkfiles//null: file does not exist: 'b/opt/mkfiles//null' diff: cannot open b/opt/setup//null: file does not exist: 'b/opt/setup//null' diff: cannot open b/opt/skel/appl/cmd/t//null: file does not exist: 'b/opt/skel/appl/cmd/t//null' diff: cannot open b/opt/skel/appl/cmd//null: file does not exist: 'b/opt/skel/appl/cmd//null' diff: cannot open b/opt/skel/appl/lib/t//null: file does not exist: 'b/opt/skel/appl/lib/t//null' diff: cannot open b/opt/skel/appl/lib//null: file does not exist: 'b/opt/skel/appl/lib//null' diff: cannot open b/opt/skel/appl//null: file does not exist: 'b/opt/skel/appl//null' diff: cannot open b/opt/skel/dis/cmd//null: file does not exist: 'b/opt/skel/dis/cmd//null' diff: cannot open b/opt/skel/dis/lib//null: file does not exist: 'b/opt/skel/dis/lib//null' diff: cannot open b/opt/skel/dis//null: file does not exist: 'b/opt/skel/dis//null' diff: cannot open b/opt/skel/doc/1//null: file does not exist: 'b/opt/skel/doc/1//null' diff: cannot open b/opt/skel/doc/2//null: file does not exist: 'b/opt/skel/doc/2//null' diff: cannot open b/opt/skel/doc//null: file does not exist: 'b/opt/skel/doc//null' diff: cannot open b/opt/skel/man/1//null: file does not exist: 'b/opt/skel/man/1//null' diff: cannot open b/opt/skel/man/2//null: file does not exist: 'b/opt/skel/man/2//null' diff: cannot open b/opt/skel/man//null: file does not exist: 'b/opt/skel/man//null' diff: cannot open b/opt/skel/module//null: file does not exist: 'b/opt/skel/module//null' diff: cannot open b/opt/skel//null: file does not exist: 'b/opt/skel//null' diff: cannot open b/usr/inferno/lib//null: file does not exist: 'b/usr/inferno/lib//null' diff: cannot open b/usr/inferno//null: file does not exist: 'b/usr/inferno//null' diff: cannot open b/usr//null: file does not exist: 'b/usr//null' 
binary files a/Linux/386/bin/c2l b/Linux/386/bin/c2l differ
binary files a/Linux/386/bin/data2c b/Linux/386/bin/data2c differ
binary files a/Linux/386/bin/ftl b/Linux/386/bin/ftl differ
binary files a/Linux/386/bin/iar b/Linux/386/bin/iar differ
binary files a/Linux/386/bin/idea b/Linux/386/bin/idea differ
binary files a/Linux/386/bin/inm b/Linux/386/bin/inm differ
binary files a/Linux/386/bin/iyacc b/Linux/386/bin/iyacc differ
binary files a/Linux/386/bin/kprof b/Linux/386/bin/kprof differ
binary files a/Linux/386/bin/ksize b/Linux/386/bin/ksize differ
binary files a/Linux/386/bin/kstrip b/Linux/386/bin/kstrip differ
binary files a/Linux/386/bin/md5sum b/Linux/386/bin/md5sum differ
binary files a/Linux/386/bin/mk b/Linux/386/bin/mk differ
binary files a/Linux/386/bin/mk.save b/Linux/386/bin/mk.save differ
binary files a/Linux/386/bin/mkext b/Linux/386/bin/mkext differ
binary files a/Linux/386/bin/mkppcimage b/Linux/386/bin/mkppcimage differ
binary files a/Linux/386/bin/ms2 b/Linux/386/bin/ms2 differ
binary files a/Linux/386/bin/ndate b/Linux/386/bin/ndate differ
binary files a/Linux/386/bin/sqz b/Linux/386/bin/sqz differ
binary files a/Linux/386/bin/srclist b/Linux/386/bin/srclist differ
binary files a/Linux/386/bin/styxtest b/Linux/386/bin/styxtest differ
--- /dev/null
+++ b/POSTINSTALL
@@ -1,0 +1,11 @@
+Post-installation setup procedures
+
+When in doubt, refer to the install document located in /doc.
+
+If directories are missing, run makestubs as per:
+
+	$ emu
+	; makestubs
+
+if Inferno is being hosted.
+
--- a/dis/lc
+++ b/dis/lc
@@ -1,2 +1,2 @@
 #!/dis/sh
-ls -p $* | mc
+ls -Fp $* | mc
--- /dev/null
+++ b/dis/ll
@@ -1,0 +1,2 @@
+#!/dis/sh
+ls -sl $*
--- /dev/null
+++ b/dis/makestubs
@@ -1,0 +1,14 @@
+#!/dis/sh
+# Initialise stub directories that may be missing in the base install
+# Opt material courtesy of powerman
+user=`{cat /dev/user}
+home=/usr/$user
+dirs=($home/keyring /tmp /mnt/keys /mnt/registry /n/remote /chan /keydb)
+
+mkdir -p $home
+cp -r /usr/inferno/* $home/
+
+for i in $dirs {
+	mkdir -p $i
+}
+
binary files /dev/null b/fonts/pelm/currency.9 differ
binary files /dev/null b/fonts/pelm/encalpha.9 differ
binary files /dev/null b/fonts/pelm/fffd.9 differ
binary files /dev/null b/fonts/pelm/latin1.8 differ
binary files /dev/null b/fonts/pelm/latin1.9 differ
binary files /dev/null b/fonts/pelm/latineur.8 differ
binary files /dev/null b/fonts/pelm/latineur.9 differ
binary files /dev/null b/fonts/pelm/supsub.8 differ
binary files /dev/null b/fonts/pelm/supsub.9 differ
--- /dev/null
+++ b/libinterp/cryptmod.h
@@ -1,0 +1,41 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Cryptmodtab[]={
+	"aescbc",0xac616ba,Crypt_aescbc,48,2,{0x0,0xc0,},
+	"aessetup",0x44452583,Crypt_aessetup,40,2,{0x0,0xc0,},
+	"blowfishcbc",0xac616ba,Crypt_blowfishcbc,48,2,{0x0,0xc0,},
+	"blowfishsetup",0x44452583,Crypt_blowfishsetup,40,2,{0x0,0xc0,},
+	"DigestState.copy",0x491fbd11,DigestState_copy,40,2,{0x0,0x80,},
+	"descbc",0xac616ba,Crypt_descbc,48,2,{0x0,0xc0,},
+	"desecb",0xac616ba,Crypt_desecb,48,2,{0x0,0xc0,},
+	"dessetup",0x44452583,Crypt_dessetup,40,2,{0x0,0xc0,},
+	"dhparams",0x6abb2418,Crypt_dhparams,40,0,{0},
+	"dsagen",0xfca97ad3,Crypt_dsagen,40,2,{0x0,0x80,},
+	"eggen",0x6e59448f,Crypt_eggen,40,0,{0},
+	"genSK",0x5d82edbe,Crypt_genSK,40,2,{0x0,0x80,},
+	"genSKfromPK",0x368c3183,Crypt_genSKfromPK,40,2,{0x0,0x80,},
+	"hmac_md5",0xec9ac159,Crypt_hmac_md5,56,2,{0x0,0xb8,},
+	"hmac_sha1",0xec9ac159,Crypt_hmac_sha1,56,2,{0x0,0xb8,},
+	"ideacbc",0xac616ba,Crypt_ideacbc,48,2,{0x0,0xc0,},
+	"ideaecb",0xac616ba,Crypt_ideaecb,48,2,{0x0,0xc0,},
+	"ideasetup",0x44452583,Crypt_ideasetup,40,2,{0x0,0xc0,},
+	"md4",0x7656377,Crypt_md4,48,2,{0x0,0xb0,},
+	"md5",0x7656377,Crypt_md5,48,2,{0x0,0xb0,},
+	"rc4",0xd051c505,Crypt_rc4,48,2,{0x0,0xc0,},
+	"rc4back",0x3643caf7,Crypt_rc4back,40,2,{0x0,0x80,},
+	"rc4setup",0x6fa90725,Crypt_rc4setup,40,2,{0x0,0x80,},
+	"rc4skip",0x3643caf7,Crypt_rc4skip,40,2,{0x0,0x80,},
+	"rsadecrypt",0x91e80677,Crypt_rsadecrypt,40,2,{0x0,0xc0,},
+	"rsaencrypt",0x3cddeb19,Crypt_rsaencrypt,40,2,{0x0,0xc0,},
+	"rsafill",0x621f5851,Crypt_rsafill,56,2,{0x0,0xf8,},
+	"rsagen",0xa59005ba,Crypt_rsagen,48,0,{0},
+	"sha1",0x7656377,Crypt_sha1,48,2,{0x0,0xb0,},
+	"sha224",0x7656377,Crypt_sha224,48,2,{0x0,0xb0,},
+	"sha256",0x7656377,Crypt_sha256,48,2,{0x0,0xb0,},
+	"sha384",0x7656377,Crypt_sha384,48,2,{0x0,0xb0,},
+	"sha512",0x7656377,Crypt_sha512,48,2,{0x0,0xb0,},
+	"sign",0xe955b4f2,Crypt_sign,40,2,{0x0,0xc0,},
+	"sktopk",0x132f856e,Crypt_sktopk,40,2,{0x0,0x80,},
+	"verify",0xff419b7b,Crypt_verify,48,2,{0x0,0xe0,},
+	0
+};
+#define Cryptmodlen	36
--- /dev/null
+++ b/libinterp/drawmod.h
@@ -1,0 +1,94 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Drawmodtab[]={
+	"Rect.Xrect",0xd1fbcdc0,Rect_Xrect,64,0,{0},
+	"Point.add",0x95a87a7,Point_add,48,0,{0},
+	"Rect.addpt",0xbcba91ad,Rect_addpt,56,0,{0},
+	"Display.allocate",0x74694470,Display_allocate,40,2,{0x0,0x80,},
+	"Screen.allocate",0x1e813b8a,Screen_allocate,48,2,{0x0,0xc0,},
+	"Image.arc",0x1685a04e,Image_arc,80,2,{0x0,0x82,},
+	"Image.arcop",0x8521de24,Image_arcop,80,2,{0x0,0x82,},
+	"Image.arrow",0x7b3fc6d3,Image_arrow,48,0,{0},
+	"Font.bbox",0x541e2d08,Font_bbox,40,2,{0x0,0xc0,},
+	"Image.bezier",0x5baca124,Image_bezier,96,3,{0x0,0x80,0x8,},
+	"Image.bezierop",0xae13ba0e,Image_bezierop,96,3,{0x0,0x80,0x8,},
+	"Image.bezspline",0x70f06194,Image_bezspline,64,2,{0x0,0xc4,},
+	"Image.bezsplineop",0x94b3bea1,Image_bezsplineop,72,2,{0x0,0xc4,},
+	"Image.border",0x59381f67,Image_border,72,2,{0x0,0x82,},
+	"Image.bottom",0x642fa8b1,Image_bottom,40,2,{0x0,0x80,},
+	"Screen.bottom",0xe2817b5f,Screen_bottom,40,2,{0x0,0xc0,},
+	"Font.build",0x7fddba2c,Font_build,48,2,{0x0,0xe0,},
+	"bytesperline",0xab1724b2,Draw_bytesperline,56,0,{0},
+	"Rect.canon",0xe969971c,Rect_canon,48,0,{0},
+	"Rect.clip",0x1ad68a89,Rect_clip,64,0,{0},
+	"Display.cmap2rgb",0xda836903,Display_cmap2rgb,40,2,{0x0,0x80,},
+	"Display.cmap2rgba",0xa64b341,Display_cmap2rgba,40,2,{0x0,0x80,},
+	"Display.color",0xac54c4aa,Display_color,40,2,{0x0,0x80,},
+	"Display.colormix",0x9e941050,Display_colormix,48,2,{0x0,0x80,},
+	"Rect.combine",0x35d786ac,Rect_combine,64,0,{0},
+	"Rect.contains",0x5f13af31,Rect_contains,56,0,{0},
+	"Chans.depth",0x90b71a6,Chans_depth,40,0,{0},
+	"Point.div",0x7f0ac44e,Point_div,48,0,{0},
+	"Image.draw",0xe2951762,Image_draw,72,2,{0x0,0x86,},
+	"Image.drawop",0x7e2751d3,Image_drawop,72,2,{0x0,0x86,},
+	"Rect.dx",0x8db540cc,Rect_dx,48,0,{0},
+	"Rect.dy",0x8db540cc,Rect_dy,48,0,{0},
+	"Image.ellipse",0xea6f2000,Image_ellipse,72,2,{0x0,0x82,},
+	"Image.ellipseop",0xc0af34c6,Image_ellipseop,72,2,{0x0,0x82,},
+	"Chans.eq",0x2ba41fd4,Chans_eq,40,0,{0},
+	"Point.eq",0xd0634e59,Point_eq,48,0,{0},
+	"Rect.eq",0xd1fbcdc0,Rect_eq,64,0,{0},
+	"Image.fillarc",0x784ac6f8,Image_fillarc,72,2,{0x0,0x84,},
+	"Image.fillarcop",0xbbcdbdd,Image_fillarcop,80,2,{0x0,0x84,},
+	"Image.fillbezier",0x4a07ed44,Image_fillbezier,88,3,{0x0,0x80,0x20,},
+	"Image.fillbezierop",0xb3796aa0,Image_fillbezierop,88,3,{0x0,0x80,0x20,},
+	"Image.fillbezspline",0x4aac99aa,Image_fillbezspline,56,2,{0x0,0xd0,},
+	"Image.fillbezsplineop",0x6288a256,Image_fillbezsplineop,64,2,{0x0,0xd0,},
+	"Image.fillellipse",0xc2961c2b,Image_fillellipse,64,2,{0x0,0x84,},
+	"Image.fillellipseop",0x9816222d,Image_fillellipseop,72,2,{0x0,0x84,},
+	"Image.fillpoly",0x4aac99aa,Image_fillpoly,56,2,{0x0,0xd0,},
+	"Image.fillpolyop",0x6288a256,Image_fillpolyop,64,2,{0x0,0xd0,},
+	"Image.flush",0xb09fc26e,Image_flush,40,2,{0x0,0x80,},
+	"Image.gendraw",0xa30a11c7,Image_gendraw,80,3,{0x0,0x84,0x80,},
+	"Image.gendrawop",0x3e8228a,Image_gendrawop,80,3,{0x0,0x84,0x80,},
+	"Display.getwindow",0xdfbf1d73,Display_getwindow,56,2,{0x0,0xf0,},
+	"icossin",0x10ea0ce,Draw_icossin,40,0,{0},
+	"icossin2",0xd07585f7,Draw_icossin2,40,0,{0},
+	"Point.in",0xcf69adf9,Point_in,56,0,{0},
+	"Rect.inrect",0xd1fbcdc0,Rect_inrect,64,0,{0},
+	"Rect.inset",0x1fabb24,Rect_inset,56,0,{0},
+	"Image.line",0x7288c7b9,Image_line,80,3,{0x0,0x80,0x80,},
+	"Image.lineop",0xe34363b9,Image_lineop,80,3,{0x0,0x80,0x80,},
+	"Chans.mk",0xadae6aad,Chans_mk,40,2,{0x0,0x80,},
+	"Point.mul",0x7f0ac44e,Point_mul,48,0,{0},
+	"Image.name",0xdff53107,Image_name,48,2,{0x0,0xc0,},
+	"Display.namedimage",0x47522dfe,Display_namedimage,40,2,{0x0,0xc0,},
+	"Display.newimage",0xb8479988,Display_newimage,64,2,{0x0,0x80,},
+	"Screen.newwindow",0xcf19f7a8,Screen_newwindow,64,2,{0x0,0x80,},
+	"Display.open",0x47522dfe,Display_open,40,2,{0x0,0xc0,},
+	"Font.open",0xddcb2ff0,Font_open,40,2,{0x0,0xc0,},
+	"Image.origin",0x9171b0bd,Image_origin,56,2,{0x0,0x80,},
+	"Image.poly",0x70f06194,Image_poly,64,2,{0x0,0xc4,},
+	"Image.polyop",0x94b3bea1,Image_polyop,72,2,{0x0,0xc4,},
+	"Display.publicscreen",0x507e0780,Display_publicscreen,40,2,{0x0,0x80,},
+	"Display.readimage",0xd38f4d48,Display_readimage,40,2,{0x0,0xc0,},
+	"Image.readpixels",0x93d30c7c,Image_readpixels,56,2,{0x0,0x84,},
+	"Display.rgb",0x8e71a513,Display_rgb,48,2,{0x0,0x80,},
+	"Display.rgb2cmap",0xbf6c3d95,Display_rgb2cmap,48,2,{0x0,0x80,},
+	"setalpha",0x6584767b,Draw_setalpha,40,0,{0},
+	"Rect.size",0x3ecfd83e,Rect_size,48,0,{0},
+	"Display.startrefresh",0xf0df9cae,Display_startrefresh,40,2,{0x0,0x80,},
+	"Point.sub",0x95a87a7,Point_sub,48,0,{0},
+	"Rect.subpt",0xbcba91ad,Rect_subpt,56,0,{0},
+	"Chans.text",0xb20b7b7b,Chans_text,40,0,{0},
+	"Image.text",0xa5927686,Image_text,64,2,{0x0,0x93,},
+	"Image.textbg",0xbbb55403,Image_textbg,80,3,{0x0,0x93,0x80,},
+	"Image.textbgop",0xea84ed21,Image_textbgop,80,3,{0x0,0x93,0x80,},
+	"Image.textop",0x22b71b43,Image_textop,72,2,{0x0,0x93,},
+	"Image.top",0x642fa8b1,Image_top,40,2,{0x0,0x80,},
+	"Screen.top",0xe2817b5f,Screen_top,40,2,{0x0,0xc0,},
+	"Font.width",0x1c70cba4,Font_width,40,2,{0x0,0xc0,},
+	"Display.writeimage",0x7bd53940,Display_writeimage,48,2,{0x0,0xe0,},
+	"Image.writepixels",0x93d30c7c,Image_writepixels,56,2,{0x0,0x84,},
+	0
+};
+#define Drawmodlen	89
--- /dev/null
+++ b/libinterp/freetypemod.h
@@ -1,0 +1,11 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Freetypemodtab[]={
+	"Face.haschar",0x6a7da190,Face_haschar,40,2,{0x0,0x80,},
+	"Face.loadglyph",0xdd275b67,Face_loadglyph,40,2,{0x0,0x80,},
+	"newface",0x18a90be,Freetype_newface,40,2,{0x0,0x80,},
+	"newmemface",0xc56f82dd,Freetype_newmemface,40,2,{0x0,0x80,},
+	"Face.setcharsize",0xb282ce87,Face_setcharsize,48,2,{0x0,0x80,},
+	"Face.settransform",0xcf26b85e,Face_settransform,48,2,{0x0,0xe0,},
+	0
+};
+#define Freetypemodlen	6
--- /dev/null
+++ b/libinterp/ipintsmod.h
@@ -1,0 +1,40 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab IPintsmodtab[]={
+	"DSAprimes",0x40d03bb6,IPints_DSAprimes,32,0,{0},
+	"IPint.add",0xa47c1b24,IPint_add,40,2,{0x0,0xc0,},
+	"IPint.and",0xa47c1b24,IPint_and,40,2,{0x0,0xc0,},
+	"IPint.b64toip",0xa803ee03,IPint_b64toip,40,2,{0x0,0x80,},
+	"IPint.bebytestoip",0x6fa90725,IPint_bebytestoip,40,2,{0x0,0x80,},
+	"IPint.bits",0xeb4c9bad,IPint_bits,40,2,{0x0,0x80,},
+	"IPint.bytestoip",0x6fa90725,IPint_bytestoip,40,2,{0x0,0x80,},
+	"IPint.cmp",0x79774f9e,IPint_cmp,40,2,{0x0,0xc0,},
+	"IPint.copy",0x491fbd11,IPint_copy,40,2,{0x0,0x80,},
+	"IPint.div",0x4672bf61,IPint_div,40,2,{0x0,0xc0,},
+	"IPint.eq",0x79774f9e,IPint_eq,40,2,{0x0,0xc0,},
+	"IPint.expmod",0xe6105024,IPint_expmod,48,2,{0x0,0xe0,},
+	"genprime",0x70bcd6f1,IPints_genprime,40,0,{0},
+	"gensafeprime",0x9a3f0392,IPints_gensafeprime,40,0,{0},
+	"genstrongprime",0x70bcd6f1,IPints_genstrongprime,40,0,{0},
+	"IPint.inttoip",0x95dc8b6d,IPint_inttoip,40,0,{0},
+	"IPint.invert",0xa47c1b24,IPint_invert,40,2,{0x0,0xc0,},
+	"IPint.iptob64",0xfab4eb8a,IPint_iptob64,40,2,{0x0,0x80,},
+	"IPint.iptob64z",0xfab4eb8a,IPint_iptob64z,40,2,{0x0,0x80,},
+	"IPint.iptobebytes",0xc8e5162d,IPint_iptobebytes,40,2,{0x0,0x80,},
+	"IPint.iptobytes",0xc8e5162d,IPint_iptobytes,40,2,{0x0,0x80,},
+	"IPint.iptoint",0xeb4c9bad,IPint_iptoint,40,2,{0x0,0x80,},
+	"IPint.iptostr",0xf9fdc03d,IPint_iptostr,40,2,{0x0,0x80,},
+	"IPint.mod",0xa47c1b24,IPint_mod,40,2,{0x0,0xc0,},
+	"IPint.mul",0xa47c1b24,IPint_mul,40,2,{0x0,0xc0,},
+	"IPint.neg",0x491fbd11,IPint_neg,40,2,{0x0,0x80,},
+	"IPint.not",0x491fbd11,IPint_not,40,2,{0x0,0x80,},
+	"IPint.ori",0xa47c1b24,IPint_ori,40,2,{0x0,0xc0,},
+	"probably_prime",0xd67dfdfa,IPints_probably_prime,40,2,{0x0,0x80,},
+	"IPint.random",0x95dc8b6d,IPint_random,40,0,{0},
+	"IPint.shl",0xc7b0bc01,IPint_shl,40,2,{0x0,0x80,},
+	"IPint.shr",0xc7b0bc01,IPint_shr,40,2,{0x0,0x80,},
+	"IPint.strtoip",0x12d7a943,IPint_strtoip,40,2,{0x0,0x80,},
+	"IPint.sub",0xa47c1b24,IPint_sub,40,2,{0x0,0xc0,},
+	"IPint.xor",0xa47c1b24,IPint_xor,40,2,{0x0,0xc0,},
+	0
+};
+#define IPintsmodlen	35
--- /dev/null
+++ b/libinterp/keyring.h
@@ -1,0 +1,99 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Keyringmodtab[]={
+	"IPint.add",0xa47c1b24,IPint_add,40,2,{0x0,0xc0,},
+	"aescbc",0xac616ba,Keyring_aescbc,48,2,{0x0,0xc0,},
+	"aessetup",0x44452583,Keyring_aessetup,40,2,{0x0,0xc0,},
+	"IPint.and",0xa47c1b24,IPint_and,40,2,{0x0,0xc0,},
+	"auth",0x9c576bb,Keyring_auth,48,2,{0x0,0xc0,},
+	"IPint.b64toip",0xa803ee03,IPint_b64toip,40,2,{0x0,0x80,},
+	"IPint.bebytestoip",0x6fa90725,IPint_bebytestoip,40,2,{0x0,0x80,},
+	"IPint.bits",0xeb4c9bad,IPint_bits,40,2,{0x0,0x80,},
+	"blowfishcbc",0xac616ba,Keyring_blowfishcbc,48,2,{0x0,0xc0,},
+	"blowfishsetup",0x44452583,Keyring_blowfishsetup,40,2,{0x0,0xc0,},
+	"IPint.bytestoip",0x6fa90725,IPint_bytestoip,40,2,{0x0,0x80,},
+	"certtoattr",0xbc65254a,Keyring_certtoattr,40,2,{0x0,0x80,},
+	"certtostr",0xbc65254a,Keyring_certtostr,40,2,{0x0,0x80,},
+	"IPint.cmp",0x79774f9e,IPint_cmp,40,2,{0x0,0xc0,},
+	"IPint.copy",0x491fbd11,IPint_copy,40,2,{0x0,0x80,},
+	"DigestState.copy",0x491fbd11,DigestState_copy,40,2,{0x0,0x80,},
+	"RSAsk.decrypt",0xf3b51b95,RSAsk_decrypt,40,2,{0x0,0xc0,},
+	"descbc",0xac616ba,Keyring_descbc,48,2,{0x0,0xc0,},
+	"desecb",0xac616ba,Keyring_desecb,48,2,{0x0,0xc0,},
+	"dessetup",0x44452583,Keyring_dessetup,40,2,{0x0,0xc0,},
+	"dhparams",0x6abb2418,Keyring_dhparams,40,0,{0},
+	"IPint.div",0x4672bf61,IPint_div,40,2,{0x0,0xc0,},
+	"RSApk.encrypt",0xdc0ec366,RSApk_encrypt,40,2,{0x0,0xc0,},
+	"IPint.eq",0x79774f9e,IPint_eq,40,2,{0x0,0xc0,},
+	"IPint.expmod",0xe6105024,IPint_expmod,48,2,{0x0,0xe0,},
+	"RSAsk.fill",0x2ab0d50a,RSAsk_fill,56,2,{0x0,0xf8,},
+	"RSAsk.gen",0xc197fd0,RSAsk_gen,48,0,{0},
+	"DSAsk.gen",0x46f0eb94,DSAsk_gen,40,2,{0x0,0x80,},
+	"EGsk.gen",0x4a59c528,EGsk_gen,40,0,{0},
+	"genSK",0xadd8cbd9,Keyring_genSK,48,2,{0x0,0xc0,},
+	"genSKfromPK",0x5416d1ee,Keyring_genSKfromPK,40,2,{0x0,0xc0,},
+	"getbytearray",0x4e02ce80,Keyring_getbytearray,40,2,{0x0,0x80,},
+	"getmsg",0xd9de1bb7,Keyring_getmsg,40,2,{0x0,0x80,},
+	"getstring",0x92f10e56,Keyring_getstring,40,2,{0x0,0x80,},
+	"hmac_md5",0xec9ac159,Keyring_hmac_md5,56,2,{0x0,0xb8,},
+	"hmac_sha1",0xec9ac159,Keyring_hmac_sha1,56,2,{0x0,0xb8,},
+	"ideacbc",0xac616ba,Keyring_ideacbc,48,2,{0x0,0xc0,},
+	"ideaecb",0xac616ba,Keyring_ideaecb,48,2,{0x0,0xc0,},
+	"ideasetup",0x44452583,Keyring_ideasetup,40,2,{0x0,0xc0,},
+	"IPint.inttoip",0x95dc8b6d,IPint_inttoip,40,0,{0},
+	"IPint.invert",0xa47c1b24,IPint_invert,40,2,{0x0,0xc0,},
+	"IPint.iptob64",0xfab4eb8a,IPint_iptob64,40,2,{0x0,0x80,},
+	"IPint.iptob64z",0xfab4eb8a,IPint_iptob64z,40,2,{0x0,0x80,},
+	"IPint.iptobebytes",0xc8e5162d,IPint_iptobebytes,40,2,{0x0,0x80,},
+	"IPint.iptobytes",0xc8e5162d,IPint_iptobytes,40,2,{0x0,0x80,},
+	"IPint.iptoint",0xeb4c9bad,IPint_iptoint,40,2,{0x0,0x80,},
+	"IPint.iptostr",0xf9fdc03d,IPint_iptostr,40,2,{0x0,0x80,},
+	"md4",0x7656377,Keyring_md4,48,2,{0x0,0xb0,},
+	"md5",0x7656377,Keyring_md5,48,2,{0x0,0xb0,},
+	"IPint.mod",0xa47c1b24,IPint_mod,40,2,{0x0,0xc0,},
+	"IPint.mul",0xa47c1b24,IPint_mul,40,2,{0x0,0xc0,},
+	"IPint.neg",0x491fbd11,IPint_neg,40,2,{0x0,0x80,},
+	"IPint.not",0x491fbd11,IPint_not,40,2,{0x0,0x80,},
+	"IPint.ori",0xa47c1b24,IPint_ori,40,2,{0x0,0xc0,},
+	"pktoattr",0xfb4e61ba,Keyring_pktoattr,40,2,{0x0,0x80,},
+	"pktostr",0xfb4e61ba,Keyring_pktostr,40,2,{0x0,0x80,},
+	"putbytearray",0x7cfef557,Keyring_putbytearray,48,2,{0x0,0xc0,},
+	"puterror",0xd2526222,Keyring_puterror,40,2,{0x0,0xc0,},
+	"putstring",0xd2526222,Keyring_putstring,40,2,{0x0,0xc0,},
+	"IPint.random",0x70bcd6f1,IPint_random,40,0,{0},
+	"rc4",0xd051c505,Keyring_rc4,48,2,{0x0,0xc0,},
+	"rc4back",0x3643caf7,Keyring_rc4back,40,2,{0x0,0x80,},
+	"rc4setup",0x6fa90725,Keyring_rc4setup,40,2,{0x0,0x80,},
+	"rc4skip",0x3643caf7,Keyring_rc4skip,40,2,{0x0,0x80,},
+	"readauthinfo",0xb2c82015,Keyring_readauthinfo,40,2,{0x0,0x80,},
+	"senderrmsg",0xd2526222,Keyring_senderrmsg,40,2,{0x0,0xc0,},
+	"sendmsg",0x7cfef557,Keyring_sendmsg,48,2,{0x0,0xc0,},
+	"sha1",0x7656377,Keyring_sha1,48,2,{0x0,0xb0,},
+	"sha224",0x7656377,Keyring_sha224,48,2,{0x0,0xb0,},
+	"sha256",0x7656377,Keyring_sha256,48,2,{0x0,0xb0,},
+	"sha384",0x7656377,Keyring_sha384,48,2,{0x0,0xb0,},
+	"sha512",0x7656377,Keyring_sha512,48,2,{0x0,0xb0,},
+	"IPint.shl",0xc7b0bc01,IPint_shl,40,2,{0x0,0x80,},
+	"IPint.shr",0xc7b0bc01,IPint_shr,40,2,{0x0,0x80,},
+	"sign",0xdacb7a7e,Keyring_sign,48,2,{0x0,0xb0,},
+	"RSAsk.sign",0x5dbdc2fe,RSAsk_sign,40,2,{0x0,0xc0,},
+	"DSAsk.sign",0x6e51e1b3,DSAsk_sign,40,2,{0x0,0xc0,},
+	"EGsk.sign",0xca053e70,EGsk_sign,40,2,{0x0,0xc0,},
+	"signm",0xba5bd10f,Keyring_signm,48,2,{0x0,0xe0,},
+	"sktoattr",0xfb4e61ba,Keyring_sktoattr,40,2,{0x0,0x80,},
+	"sktopk",0x6f74c7c9,Keyring_sktopk,40,2,{0x0,0x80,},
+	"sktostr",0xfb4e61ba,Keyring_sktostr,40,2,{0x0,0x80,},
+	"strtocert",0x2c0ee68a,Keyring_strtocert,40,2,{0x0,0x80,},
+	"IPint.strtoip",0x12d7a943,IPint_strtoip,40,2,{0x0,0x80,},
+	"strtopk",0xcc511522,Keyring_strtopk,40,2,{0x0,0x80,},
+	"strtosk",0xcc511522,Keyring_strtosk,40,2,{0x0,0x80,},
+	"IPint.sub",0xa47c1b24,IPint_sub,40,2,{0x0,0xc0,},
+	"verify",0x8b5b9f76,Keyring_verify,48,2,{0x0,0xe0,},
+	"RSApk.verify",0x1857beff,RSApk_verify,48,2,{0x0,0xe0,},
+	"DSApk.verify",0xeca448ff,DSApk_verify,48,2,{0x0,0xe0,},
+	"EGpk.verify",0xfb1e256c,EGpk_verify,48,2,{0x0,0xe0,},
+	"verifym",0x8b5b9f76,Keyring_verifym,48,2,{0x0,0xe0,},
+	"writeauthinfo",0x5ba03002,Keyring_writeauthinfo,40,2,{0x0,0xc0,},
+	"IPint.xor",0xa47c1b24,IPint_xor,40,2,{0x0,0xc0,},
+	0
+};
+#define Keyringmodlen	94
--- /dev/null
+++ b/libinterp/keyringif.h
@@ -1,0 +1,1692 @@
+typedef struct Sys_Qid Sys_Qid;
+typedef struct Sys_Dir Sys_Dir;
+typedef struct Sys_FD Sys_FD;
+typedef struct Sys_Connection Sys_Connection;
+typedef struct Sys_FileIO Sys_FileIO;
+typedef struct Keyring_IPint Keyring_IPint;
+typedef struct Keyring_SigAlg Keyring_SigAlg;
+typedef struct Keyring_PK Keyring_PK;
+typedef struct Keyring_SK Keyring_SK;
+typedef struct Keyring_Certificate Keyring_Certificate;
+typedef struct Keyring_DigestState Keyring_DigestState;
+typedef struct Keyring_AESstate Keyring_AESstate;
+typedef struct Keyring_DESstate Keyring_DESstate;
+typedef struct Keyring_IDEAstate Keyring_IDEAstate;
+typedef struct Keyring_RC4state Keyring_RC4state;
+typedef struct Keyring_BFstate Keyring_BFstate;
+typedef struct Keyring_Authinfo Keyring_Authinfo;
+typedef struct Keyring_RSApk Keyring_RSApk;
+typedef struct Keyring_RSAsk Keyring_RSAsk;
+typedef struct Keyring_RSAsig Keyring_RSAsig;
+typedef struct Keyring_DSApk Keyring_DSApk;
+typedef struct Keyring_DSAsk Keyring_DSAsk;
+typedef struct Keyring_DSAsig Keyring_DSAsig;
+typedef struct Keyring_EGpk Keyring_EGpk;
+typedef struct Keyring_EGsk Keyring_EGsk;
+typedef struct Keyring_EGsig Keyring_EGsig;
+struct Sys_Qid
+{
+	LONG	path;
+	WORD	vers;
+	WORD	qtype;
+};
+#define Sys_Qid_size 16
+#define Sys_Qid_map {0}
+struct Sys_Dir
+{
+	String*	name;
+	String*	uid;
+	String*	gid;
+	String*	muid;
+	Sys_Qid	qid;
+	WORD	mode;
+	WORD	atime;
+	WORD	mtime;
+	uchar	_pad44[4];
+	LONG	length;
+	WORD	dtype;
+	WORD	dev;
+};
+#define Sys_Dir_size 64
+#define Sys_Dir_map {0xf0,}
+struct Sys_FD
+{
+	WORD	fd;
+};
+#define Sys_FD_size 4
+#define Sys_FD_map {0}
+struct Sys_Connection
+{
+	Sys_FD*	dfd;
+	Sys_FD*	cfd;
+	String*	dir;
+};
+#define Sys_Connection_size 12
+#define Sys_Connection_map {0xe0,}
+typedef struct{ Array* t0; String* t1; } Sys_Rread;
+#define Sys_Rread_size 8
+#define Sys_Rread_map {0xc0,}
+typedef struct{ WORD t0; String* t1; } Sys_Rwrite;
+#define Sys_Rwrite_size 8
+#define Sys_Rwrite_map {0x40,}
+struct Sys_FileIO
+{
+	Channel*	read;
+	Channel*	write;
+};
+typedef struct{ WORD t0; WORD t1; WORD t2; Channel* t3; } Sys_FileIO_read;
+#define Sys_FileIO_read_size 16
+#define Sys_FileIO_read_map {0x10,}
+typedef struct{ WORD t0; Array* t1; WORD t2; Channel* t3; } Sys_FileIO_write;
+#define Sys_FileIO_write_size 16
+#define Sys_FileIO_write_map {0x50,}
+#define Sys_FileIO_size 8
+#define Sys_FileIO_map {0xc0,}
+struct Keyring_IPint
+{
+	WORD	x;
+};
+#define Keyring_IPint_size 4
+#define Keyring_IPint_map {0}
+struct Keyring_SigAlg
+{
+	String*	name;
+};
+#define Keyring_SigAlg_size 4
+#define Keyring_SigAlg_map {0x80,}
+struct Keyring_PK
+{
+	Keyring_SigAlg*	sa;
+	String*	owner;
+};
+#define Keyring_PK_size 8
+#define Keyring_PK_map {0xc0,}
+struct Keyring_SK
+{
+	Keyring_SigAlg*	sa;
+	String*	owner;
+};
+#define Keyring_SK_size 8
+#define Keyring_SK_map {0xc0,}
+struct Keyring_Certificate
+{
+	Keyring_SigAlg*	sa;
+	String*	ha;
+	String*	signer;
+	WORD	exp;
+};
+#define Keyring_Certificate_size 16
+#define Keyring_Certificate_map {0xe0,}
+struct Keyring_DigestState
+{
+	WORD	x;
+};
+#define Keyring_DigestState_size 4
+#define Keyring_DigestState_map {0}
+struct Keyring_AESstate
+{
+	WORD	x;
+};
+#define Keyring_AESstate_size 4
+#define Keyring_AESstate_map {0}
+struct Keyring_DESstate
+{
+	WORD	x;
+};
+#define Keyring_DESstate_size 4
+#define Keyring_DESstate_map {0}
+struct Keyring_IDEAstate
+{
+	WORD	x;
+};
+#define Keyring_IDEAstate_size 4
+#define Keyring_IDEAstate_map {0}
+struct Keyring_RC4state
+{
+	WORD	x;
+};
+#define Keyring_RC4state_size 4
+#define Keyring_RC4state_map {0}
+struct Keyring_BFstate
+{
+	WORD	x;
+};
+#define Keyring_BFstate_size 4
+#define Keyring_BFstate_map {0}
+struct Keyring_Authinfo
+{
+	Keyring_SK*	mysk;
+	Keyring_PK*	mypk;
+	Keyring_Certificate*	cert;
+	Keyring_PK*	spk;
+	Keyring_IPint*	alpha;
+	Keyring_IPint*	p;
+};
+#define Keyring_Authinfo_size 24
+#define Keyring_Authinfo_map {0xfc,}
+struct Keyring_RSApk
+{
+	Keyring_IPint*	n;
+	Keyring_IPint*	ek;
+};
+#define Keyring_RSApk_size 8
+#define Keyring_RSApk_map {0xc0,}
+struct Keyring_RSAsk
+{
+	Keyring_RSApk*	pk;
+	Keyring_IPint*	dk;
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+	Keyring_IPint*	kp;
+	Keyring_IPint*	kq;
+	Keyring_IPint*	c2;
+};
+#define Keyring_RSAsk_size 28
+#define Keyring_RSAsk_map {0xfe,}
+struct Keyring_RSAsig
+{
+	Keyring_IPint*	n;
+};
+#define Keyring_RSAsig_size 4
+#define Keyring_RSAsig_map {0x80,}
+struct Keyring_DSApk
+{
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+	Keyring_IPint*	alpha;
+	Keyring_IPint*	key;
+};
+#define Keyring_DSApk_size 16
+#define Keyring_DSApk_map {0xf0,}
+struct Keyring_DSAsk
+{
+	Keyring_DSApk*	pk;
+	Keyring_IPint*	secret;
+};
+#define Keyring_DSAsk_size 8
+#define Keyring_DSAsk_map {0xc0,}
+struct Keyring_DSAsig
+{
+	Keyring_IPint*	r;
+	Keyring_IPint*	s;
+};
+#define Keyring_DSAsig_size 8
+#define Keyring_DSAsig_map {0xc0,}
+struct Keyring_EGpk
+{
+	Keyring_IPint*	p;
+	Keyring_IPint*	alpha;
+	Keyring_IPint*	key;
+};
+#define Keyring_EGpk_size 12
+#define Keyring_EGpk_map {0xe0,}
+struct Keyring_EGsk
+{
+	Keyring_EGpk*	pk;
+	Keyring_IPint*	secret;
+};
+#define Keyring_EGsk_size 8
+#define Keyring_EGsk_map {0xc0,}
+struct Keyring_EGsig
+{
+	Keyring_IPint*	r;
+	Keyring_IPint*	s;
+};
+#define Keyring_EGsig_size 8
+#define Keyring_EGsig_map {0xc0,}
+void Sys_announce(void*);
+typedef struct F_Sys_announce F_Sys_announce;
+struct F_Sys_announce
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	String*	addr;
+};
+void Sys_aprint(void*);
+typedef struct F_Sys_aprint F_Sys_aprint;
+struct F_Sys_aprint
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_bind(void*);
+typedef struct F_Sys_bind F_Sys_bind;
+struct F_Sys_bind
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	String*	on;
+	WORD	flags;
+};
+void Sys_byte2char(void*);
+typedef struct F_Sys_byte2char F_Sys_byte2char;
+struct F_Sys_byte2char
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; WORD t2; }*	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+};
+void Sys_char2byte(void*);
+typedef struct F_Sys_char2byte F_Sys_char2byte;
+struct F_Sys_char2byte
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	c;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_chdir(void*);
+typedef struct F_Sys_chdir F_Sys_chdir;
+struct F_Sys_chdir
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	path;
+};
+void Sys_create(void*);
+typedef struct F_Sys_create F_Sys_create;
+struct F_Sys_create
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	mode;
+	WORD	perm;
+};
+void Sys_dial(void*);
+typedef struct F_Sys_dial F_Sys_dial;
+struct F_Sys_dial
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	String*	addr;
+	String*	local;
+};
+void Sys_dirread(void*);
+typedef struct F_Sys_dirread F_Sys_dirread;
+struct F_Sys_dirread
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Array* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_dup(void*);
+typedef struct F_Sys_dup F_Sys_dup;
+struct F_Sys_dup
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	old;
+	WORD	new;
+};
+void Sys_export(void*);
+typedef struct F_Sys_export F_Sys_export;
+struct F_Sys_export
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	c;
+	String*	dir;
+	WORD	flag;
+};
+void Sys_fauth(void*);
+typedef struct F_Sys_fauth F_Sys_fauth;
+struct F_Sys_fauth
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	aname;
+};
+void Sys_fd2path(void*);
+typedef struct F_Sys_fd2path F_Sys_fd2path;
+struct F_Sys_fd2path
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_fildes(void*);
+typedef struct F_Sys_fildes F_Sys_fildes;
+struct F_Sys_fildes
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	WORD	fd;
+};
+void Sys_file2chan(void*);
+typedef struct F_Sys_file2chan F_Sys_file2chan;
+struct F_Sys_file2chan
+{
+	WORD	regs[NREG-1];
+	Sys_FileIO**	ret;
+	uchar	temps[12];
+	String*	dir;
+	String*	file;
+};
+void Sys_fprint(void*);
+typedef struct F_Sys_fprint F_Sys_fprint;
+struct F_Sys_fprint
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	s;
+	WORD	vargs;
+};
+void Sys_fstat(void*);
+typedef struct F_Sys_fstat F_Sys_fstat;
+struct F_Sys_fstat
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; Sys_Dir t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_fversion(void*);
+typedef struct F_Sys_fversion F_Sys_fversion;
+struct F_Sys_fversion
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; String* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	WORD	msize;
+	String*	version;
+};
+void Sys_fwstat(void*);
+typedef struct F_Sys_fwstat F_Sys_fwstat;
+struct F_Sys_fwstat
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	uchar	_pad36[4];
+	Sys_Dir	d;
+};
+void Sys_iounit(void*);
+typedef struct F_Sys_iounit F_Sys_iounit;
+struct F_Sys_iounit
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_listen(void*);
+typedef struct F_Sys_listen F_Sys_listen;
+struct F_Sys_listen
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	Sys_Connection	c;
+};
+void Sys_millisec(void*);
+typedef struct F_Sys_millisec F_Sys_millisec;
+struct F_Sys_millisec
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+};
+void Sys_mount(void*);
+typedef struct F_Sys_mount F_Sys_mount;
+struct F_Sys_mount
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Sys_FD*	afd;
+	String*	on;
+	WORD	flags;
+	String*	spec;
+};
+void Sys_open(void*);
+typedef struct F_Sys_open F_Sys_open;
+struct F_Sys_open
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	mode;
+};
+void Sys_pctl(void*);
+typedef struct F_Sys_pctl F_Sys_pctl;
+struct F_Sys_pctl
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	flags;
+	List*	movefd;
+};
+void Sys_pipe(void*);
+typedef struct F_Sys_pipe F_Sys_pipe;
+struct F_Sys_pipe
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Array*	fds;
+};
+void Sys_pread(void*);
+typedef struct F_Sys_pread F_Sys_pread;
+struct F_Sys_pread
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+	uchar	_pad44[4];
+	LONG	off;
+};
+void Sys_print(void*);
+typedef struct F_Sys_print F_Sys_print;
+struct F_Sys_print
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_pwrite(void*);
+typedef struct F_Sys_pwrite F_Sys_pwrite;
+struct F_Sys_pwrite
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+	uchar	_pad44[4];
+	LONG	off;
+};
+void Sys_read(void*);
+typedef struct F_Sys_read F_Sys_read;
+struct F_Sys_read
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_readn(void*);
+typedef struct F_Sys_readn F_Sys_readn;
+struct F_Sys_readn
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_remove(void*);
+typedef struct F_Sys_remove F_Sys_remove;
+struct F_Sys_remove
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_seek(void*);
+typedef struct F_Sys_seek F_Sys_seek;
+struct F_Sys_seek
+{
+	WORD	regs[NREG-1];
+	LONG*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	uchar	_pad36[4];
+	LONG	off;
+	WORD	start;
+};
+void Sys_sleep(void*);
+typedef struct F_Sys_sleep F_Sys_sleep;
+struct F_Sys_sleep
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	period;
+};
+void Sys_sprint(void*);
+typedef struct F_Sys_sprint F_Sys_sprint;
+struct F_Sys_sprint
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_stat(void*);
+typedef struct F_Sys_stat F_Sys_stat;
+struct F_Sys_stat
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; Sys_Dir t1; }*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_stream(void*);
+typedef struct F_Sys_stream F_Sys_stream;
+struct F_Sys_stream
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	src;
+	Sys_FD*	dst;
+	WORD	bufsiz;
+};
+void Sys_tokenize(void*);
+typedef struct F_Sys_tokenize F_Sys_tokenize;
+struct F_Sys_tokenize
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; List* t1; }*	ret;
+	uchar	temps[12];
+	String*	s;
+	String*	delim;
+};
+void Sys_unmount(void*);
+typedef struct F_Sys_unmount F_Sys_unmount;
+struct F_Sys_unmount
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s1;
+	String*	s2;
+};
+void Sys_utfbytes(void*);
+typedef struct F_Sys_utfbytes F_Sys_utfbytes;
+struct F_Sys_utfbytes
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+};
+void Sys_werrstr(void*);
+typedef struct F_Sys_werrstr F_Sys_werrstr;
+struct F_Sys_werrstr
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_write(void*);
+typedef struct F_Sys_write F_Sys_write;
+struct F_Sys_write
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_wstat(void*);
+typedef struct F_Sys_wstat F_Sys_wstat;
+struct F_Sys_wstat
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	uchar	_pad36[4];
+	Sys_Dir	d;
+};
+#define Sys_PATH "$Sys"
+#define Sys_Maxint 2147483647
+#define Sys_QTDIR 128
+#define Sys_QTAPPEND 64
+#define Sys_QTEXCL 32
+#define Sys_QTAUTH 8
+#define Sys_QTTMP 4
+#define Sys_QTFILE 0
+#define Sys_ATOMICIO 8192
+#define Sys_SEEKSTART 0
+#define Sys_SEEKRELA 1
+#define Sys_SEEKEND 2
+#define Sys_NAMEMAX 256
+#define Sys_ERRMAX 128
+#define Sys_WAITLEN 192
+#define Sys_OREAD 0
+#define Sys_OWRITE 1
+#define Sys_ORDWR 2
+#define Sys_OTRUNC 16
+#define Sys_ORCLOSE 64
+#define Sys_OEXCL 4096
+#define Sys_DMDIR -2147483648
+#define Sys_DMAPPEND 1073741824
+#define Sys_DMEXCL 536870912
+#define Sys_DMAUTH 134217728
+#define Sys_DMTMP 67108864
+#define Sys_MREPL 0
+#define Sys_MBEFORE 1
+#define Sys_MAFTER 2
+#define Sys_MCREATE 4
+#define Sys_MCACHE 16
+#define Sys_NEWFD 1
+#define Sys_FORKFD 2
+#define Sys_NEWNS 4
+#define Sys_FORKNS 8
+#define Sys_NEWPGRP 16
+#define Sys_NODEVS 32
+#define Sys_NEWENV 64
+#define Sys_FORKENV 128
+#define Sys_EXPWAIT 0
+#define Sys_EXPASYNC 1
+#define Sys_UTFmax 4
+#define Sys_UTFerror 65533
+#define Sys_Runemax 1114111
+#define Sys_Runemask 2097151
+void IPint_add(void*);
+typedef struct F_IPint_add F_IPint_add;
+struct F_IPint_add
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void Keyring_aescbc(void*);
+typedef struct F_Keyring_aescbc F_Keyring_aescbc;
+struct F_Keyring_aescbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_AESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_aessetup(void*);
+typedef struct F_Keyring_aessetup F_Keyring_aessetup;
+struct F_Keyring_aessetup
+{
+	WORD	regs[NREG-1];
+	Keyring_AESstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void IPint_and(void*);
+typedef struct F_IPint_and F_IPint_and;
+struct F_IPint_and
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void Keyring_auth(void*);
+typedef struct F_Keyring_auth F_Keyring_auth;
+struct F_Keyring_auth
+{
+	WORD	regs[NREG-1];
+	struct{ String* t0; Array* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Keyring_Authinfo*	info;
+	WORD	setid;
+};
+void IPint_b64toip(void*);
+typedef struct F_IPint_b64toip F_IPint_b64toip;
+struct F_IPint_b64toip
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	String*	str;
+};
+void IPint_bebytestoip(void*);
+typedef struct F_IPint_bebytestoip F_IPint_bebytestoip;
+struct F_IPint_bebytestoip
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Array*	mag;
+};
+void IPint_bits(void*);
+typedef struct F_IPint_bits F_IPint_bits;
+struct F_IPint_bits
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void Keyring_blowfishcbc(void*);
+typedef struct F_Keyring_blowfishcbc F_Keyring_blowfishcbc;
+struct F_Keyring_blowfishcbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_BFstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_blowfishsetup(void*);
+typedef struct F_Keyring_blowfishsetup F_Keyring_blowfishsetup;
+struct F_Keyring_blowfishsetup
+{
+	WORD	regs[NREG-1];
+	Keyring_BFstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void IPint_bytestoip(void*);
+typedef struct F_IPint_bytestoip F_IPint_bytestoip;
+struct F_IPint_bytestoip
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Array*	buf;
+};
+void Keyring_certtoattr(void*);
+typedef struct F_Keyring_certtoattr F_Keyring_certtoattr;
+struct F_Keyring_certtoattr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_Certificate*	c;
+};
+void Keyring_certtostr(void*);
+typedef struct F_Keyring_certtostr F_Keyring_certtostr;
+struct F_Keyring_certtostr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_Certificate*	c;
+};
+void IPint_cmp(void*);
+typedef struct F_IPint_cmp F_IPint_cmp;
+struct F_IPint_cmp
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void IPint_copy(void*);
+typedef struct F_IPint_copy F_IPint_copy;
+struct F_IPint_copy
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void DigestState_copy(void*);
+typedef struct F_DigestState_copy F_DigestState_copy;
+struct F_DigestState_copy
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Keyring_DigestState*	d;
+};
+void RSAsk_decrypt(void*);
+typedef struct F_RSAsk_decrypt F_RSAsk_decrypt;
+struct F_RSAsk_decrypt
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_RSAsk*	k;
+	Keyring_IPint*	m;
+};
+void Keyring_descbc(void*);
+typedef struct F_Keyring_descbc F_Keyring_descbc;
+struct F_Keyring_descbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_DESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_desecb(void*);
+typedef struct F_Keyring_desecb F_Keyring_desecb;
+struct F_Keyring_desecb
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_DESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_dessetup(void*);
+typedef struct F_Keyring_dessetup F_Keyring_dessetup;
+struct F_Keyring_dessetup
+{
+	WORD	regs[NREG-1];
+	Keyring_DESstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void Keyring_dhparams(void*);
+typedef struct F_Keyring_dhparams F_Keyring_dhparams;
+struct F_Keyring_dhparams
+{
+	WORD	regs[NREG-1];
+	struct{ Keyring_IPint* t0; Keyring_IPint* t1; }*	ret;
+	uchar	temps[12];
+	WORD	nbits;
+};
+void IPint_div(void*);
+typedef struct F_IPint_div F_IPint_div;
+struct F_IPint_div
+{
+	WORD	regs[NREG-1];
+	struct{ Keyring_IPint* t0; Keyring_IPint* t1; }*	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void RSApk_encrypt(void*);
+typedef struct F_RSApk_encrypt F_RSApk_encrypt;
+struct F_RSApk_encrypt
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_RSApk*	k;
+	Keyring_IPint*	m;
+};
+void IPint_eq(void*);
+typedef struct F_IPint_eq F_IPint_eq;
+struct F_IPint_eq
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void IPint_expmod(void*);
+typedef struct F_IPint_expmod F_IPint_expmod;
+struct F_IPint_expmod
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	base;
+	Keyring_IPint*	exp;
+	Keyring_IPint*	mod;
+};
+void RSAsk_fill(void*);
+typedef struct F_RSAsk_fill F_RSAsk_fill;
+struct F_RSAsk_fill
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsk**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	n;
+	Keyring_IPint*	e;
+	Keyring_IPint*	d;
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+};
+void RSAsk_gen(void*);
+typedef struct F_RSAsk_gen F_RSAsk_gen;
+struct F_RSAsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsk**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	elen;
+	WORD	nrep;
+};
+void DSAsk_gen(void*);
+typedef struct F_DSAsk_gen F_DSAsk_gen;
+struct F_DSAsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_DSAsk**	ret;
+	uchar	temps[12];
+	Keyring_DSApk*	oldpk;
+};
+void EGsk_gen(void*);
+typedef struct F_EGsk_gen F_EGsk_gen;
+struct F_EGsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_EGsk**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	nrep;
+};
+void Keyring_genSK(void*);
+typedef struct F_Keyring_genSK F_Keyring_genSK;
+struct F_Keyring_genSK
+{
+	WORD	regs[NREG-1];
+	Keyring_SK**	ret;
+	uchar	temps[12];
+	String*	algname;
+	String*	owner;
+	WORD	length;
+};
+void Keyring_genSKfromPK(void*);
+typedef struct F_Keyring_genSKfromPK F_Keyring_genSKfromPK;
+struct F_Keyring_genSKfromPK
+{
+	WORD	regs[NREG-1];
+	Keyring_SK**	ret;
+	uchar	temps[12];
+	Keyring_PK*	pk;
+	String*	owner;
+};
+void Keyring_getbytearray(void*);
+typedef struct F_Keyring_getbytearray F_Keyring_getbytearray;
+struct F_Keyring_getbytearray
+{
+	WORD	regs[NREG-1];
+	struct{ Array* t0; String* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Keyring_getmsg(void*);
+typedef struct F_Keyring_getmsg F_Keyring_getmsg;
+struct F_Keyring_getmsg
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Keyring_getstring(void*);
+typedef struct F_Keyring_getstring F_Keyring_getstring;
+struct F_Keyring_getstring
+{
+	WORD	regs[NREG-1];
+	struct{ String* t0; String* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Keyring_hmac_md5(void*);
+typedef struct F_Keyring_hmac_md5 F_Keyring_hmac_md5;
+struct F_Keyring_hmac_md5
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	data;
+	WORD	n;
+	Array*	key;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_hmac_sha1(void*);
+typedef struct F_Keyring_hmac_sha1 F_Keyring_hmac_sha1;
+struct F_Keyring_hmac_sha1
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	data;
+	WORD	n;
+	Array*	key;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_ideacbc(void*);
+typedef struct F_Keyring_ideacbc F_Keyring_ideacbc;
+struct F_Keyring_ideacbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_IDEAstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_ideaecb(void*);
+typedef struct F_Keyring_ideaecb F_Keyring_ideaecb;
+struct F_Keyring_ideaecb
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_IDEAstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_ideasetup(void*);
+typedef struct F_Keyring_ideasetup F_Keyring_ideasetup;
+struct F_Keyring_ideasetup
+{
+	WORD	regs[NREG-1];
+	Keyring_IDEAstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void IPint_inttoip(void*);
+typedef struct F_IPint_inttoip F_IPint_inttoip;
+struct F_IPint_inttoip
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	WORD	i;
+};
+void IPint_invert(void*);
+typedef struct F_IPint_invert F_IPint_invert;
+struct F_IPint_invert
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	base;
+	Keyring_IPint*	mod;
+};
+void IPint_iptob64(void*);
+typedef struct F_IPint_iptob64 F_IPint_iptob64;
+struct F_IPint_iptob64
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_iptob64z(void*);
+typedef struct F_IPint_iptob64z F_IPint_iptob64z;
+struct F_IPint_iptob64z
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_iptobebytes(void*);
+typedef struct F_IPint_iptobebytes F_IPint_iptobebytes;
+struct F_IPint_iptobebytes
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_iptobytes(void*);
+typedef struct F_IPint_iptobytes F_IPint_iptobytes;
+struct F_IPint_iptobytes
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_iptoint(void*);
+typedef struct F_IPint_iptoint F_IPint_iptoint;
+struct F_IPint_iptoint
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_iptostr(void*);
+typedef struct F_IPint_iptostr F_IPint_iptostr;
+struct F_IPint_iptostr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+	WORD	base;
+};
+void Keyring_md4(void*);
+typedef struct F_Keyring_md4 F_Keyring_md4;
+struct F_Keyring_md4
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_md5(void*);
+typedef struct F_Keyring_md5 F_Keyring_md5;
+struct F_Keyring_md5
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void IPint_mod(void*);
+typedef struct F_IPint_mod F_IPint_mod;
+struct F_IPint_mod
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void IPint_mul(void*);
+typedef struct F_IPint_mul F_IPint_mul;
+struct F_IPint_mul
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void IPint_neg(void*);
+typedef struct F_IPint_neg F_IPint_neg;
+struct F_IPint_neg
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
+void IPint_not(void*);
+typedef struct F_IPint_not F_IPint_not;
+struct F_IPint_not
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+};
+void IPint_ori(void*);
+typedef struct F_IPint_ori F_IPint_ori;
+struct F_IPint_ori
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void Keyring_pktoattr(void*);
+typedef struct F_Keyring_pktoattr F_Keyring_pktoattr;
+struct F_Keyring_pktoattr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_PK*	pk;
+};
+void Keyring_pktostr(void*);
+typedef struct F_Keyring_pktostr F_Keyring_pktostr;
+struct F_Keyring_pktostr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_PK*	pk;
+};
+void Keyring_putbytearray(void*);
+typedef struct F_Keyring_putbytearray F_Keyring_putbytearray;
+struct F_Keyring_putbytearray
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	a;
+	WORD	n;
+};
+void Keyring_puterror(void*);
+typedef struct F_Keyring_puterror F_Keyring_puterror;
+struct F_Keyring_puterror
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	s;
+};
+void Keyring_putstring(void*);
+typedef struct F_Keyring_putstring F_Keyring_putstring;
+struct F_Keyring_putstring
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	s;
+};
+void IPint_random(void*);
+typedef struct F_IPint_random F_IPint_random;
+struct F_IPint_random
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	WORD	minbits;
+	WORD	maxbits;
+};
+void Keyring_rc4(void*);
+typedef struct F_Keyring_rc4 F_Keyring_rc4;
+struct F_Keyring_rc4
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_RC4state*	state;
+	Array*	buf;
+	WORD	n;
+};
+void Keyring_rc4back(void*);
+typedef struct F_Keyring_rc4back F_Keyring_rc4back;
+struct F_Keyring_rc4back
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_RC4state*	state;
+	WORD	n;
+};
+void Keyring_rc4setup(void*);
+typedef struct F_Keyring_rc4setup F_Keyring_rc4setup;
+struct F_Keyring_rc4setup
+{
+	WORD	regs[NREG-1];
+	Keyring_RC4state**	ret;
+	uchar	temps[12];
+	Array*	seed;
+};
+void Keyring_rc4skip(void*);
+typedef struct F_Keyring_rc4skip F_Keyring_rc4skip;
+struct F_Keyring_rc4skip
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_RC4state*	state;
+	WORD	n;
+};
+void Keyring_readauthinfo(void*);
+typedef struct F_Keyring_readauthinfo F_Keyring_readauthinfo;
+struct F_Keyring_readauthinfo
+{
+	WORD	regs[NREG-1];
+	Keyring_Authinfo**	ret;
+	uchar	temps[12];
+	String*	filename;
+};
+void Keyring_senderrmsg(void*);
+typedef struct F_Keyring_senderrmsg F_Keyring_senderrmsg;
+struct F_Keyring_senderrmsg
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	s;
+};
+void Keyring_sendmsg(void*);
+typedef struct F_Keyring_sendmsg F_Keyring_sendmsg;
+struct F_Keyring_sendmsg
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Keyring_sha1(void*);
+typedef struct F_Keyring_sha1 F_Keyring_sha1;
+struct F_Keyring_sha1
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_sha224(void*);
+typedef struct F_Keyring_sha224 F_Keyring_sha224;
+struct F_Keyring_sha224
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_sha256(void*);
+typedef struct F_Keyring_sha256 F_Keyring_sha256;
+struct F_Keyring_sha256
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_sha384(void*);
+typedef struct F_Keyring_sha384 F_Keyring_sha384;
+struct F_Keyring_sha384
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void Keyring_sha512(void*);
+typedef struct F_Keyring_sha512 F_Keyring_sha512;
+struct F_Keyring_sha512
+{
+	WORD	regs[NREG-1];
+	Keyring_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Keyring_DigestState*	state;
+};
+void IPint_shl(void*);
+typedef struct F_IPint_shl F_IPint_shl;
+struct F_IPint_shl
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+	WORD	n;
+};
+void IPint_shr(void*);
+typedef struct F_IPint_shr F_IPint_shr;
+struct F_IPint_shr
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+	WORD	n;
+};
+void Keyring_sign(void*);
+typedef struct F_Keyring_sign F_Keyring_sign;
+struct F_Keyring_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_Certificate**	ret;
+	uchar	temps[12];
+	Keyring_SK*	sk;
+	WORD	exp;
+	Keyring_DigestState*	state;
+	String*	ha;
+};
+void RSAsk_sign(void*);
+typedef struct F_RSAsk_sign F_RSAsk_sign;
+struct F_RSAsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsig**	ret;
+	uchar	temps[12];
+	Keyring_RSAsk*	k;
+	Keyring_IPint*	m;
+};
+void DSAsk_sign(void*);
+typedef struct F_DSAsk_sign F_DSAsk_sign;
+struct F_DSAsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_DSAsig**	ret;
+	uchar	temps[12];
+	Keyring_DSAsk*	k;
+	Keyring_IPint*	m;
+};
+void EGsk_sign(void*);
+typedef struct F_EGsk_sign F_EGsk_sign;
+struct F_EGsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_EGsig**	ret;
+	uchar	temps[12];
+	Keyring_EGsk*	k;
+	Keyring_IPint*	m;
+};
+void Keyring_signm(void*);
+typedef struct F_Keyring_signm F_Keyring_signm;
+struct F_Keyring_signm
+{
+	WORD	regs[NREG-1];
+	Keyring_Certificate**	ret;
+	uchar	temps[12];
+	Keyring_SK*	sk;
+	Keyring_IPint*	m;
+	String*	ha;
+};
+void Keyring_sktoattr(void*);
+typedef struct F_Keyring_sktoattr F_Keyring_sktoattr;
+struct F_Keyring_sktoattr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_SK*	sk;
+};
+void Keyring_sktopk(void*);
+typedef struct F_Keyring_sktopk F_Keyring_sktopk;
+struct F_Keyring_sktopk
+{
+	WORD	regs[NREG-1];
+	Keyring_PK**	ret;
+	uchar	temps[12];
+	Keyring_SK*	sk;
+};
+void Keyring_sktostr(void*);
+typedef struct F_Keyring_sktostr F_Keyring_sktostr;
+struct F_Keyring_sktostr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_SK*	sk;
+};
+void Keyring_strtocert(void*);
+typedef struct F_Keyring_strtocert F_Keyring_strtocert;
+struct F_Keyring_strtocert
+{
+	WORD	regs[NREG-1];
+	Keyring_Certificate**	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void IPint_strtoip(void*);
+typedef struct F_IPint_strtoip F_IPint_strtoip;
+struct F_IPint_strtoip
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	String*	str;
+	WORD	base;
+};
+void Keyring_strtopk(void*);
+typedef struct F_Keyring_strtopk F_Keyring_strtopk;
+struct F_Keyring_strtopk
+{
+	WORD	regs[NREG-1];
+	Keyring_PK**	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Keyring_strtosk(void*);
+typedef struct F_Keyring_strtosk F_Keyring_strtosk;
+struct F_Keyring_strtosk
+{
+	WORD	regs[NREG-1];
+	Keyring_SK**	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void IPint_sub(void*);
+typedef struct F_IPint_sub F_IPint_sub;
+struct F_IPint_sub
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+void Keyring_verify(void*);
+typedef struct F_Keyring_verify F_Keyring_verify;
+struct F_Keyring_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_PK*	pk;
+	Keyring_Certificate*	cert;
+	Keyring_DigestState*	state;
+};
+void RSApk_verify(void*);
+typedef struct F_RSApk_verify F_RSApk_verify;
+struct F_RSApk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_RSApk*	k;
+	Keyring_RSAsig*	sig;
+	Keyring_IPint*	m;
+};
+void DSApk_verify(void*);
+typedef struct F_DSApk_verify F_DSApk_verify;
+struct F_DSApk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_DSApk*	k;
+	Keyring_DSAsig*	sig;
+	Keyring_IPint*	m;
+};
+void EGpk_verify(void*);
+typedef struct F_EGpk_verify F_EGpk_verify;
+struct F_EGpk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_EGpk*	k;
+	Keyring_EGsig*	sig;
+	Keyring_IPint*	m;
+};
+void Keyring_verifym(void*);
+typedef struct F_Keyring_verifym F_Keyring_verifym;
+struct F_Keyring_verifym
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_PK*	pk;
+	Keyring_Certificate*	cert;
+	Keyring_IPint*	m;
+};
+void Keyring_writeauthinfo(void*);
+typedef struct F_Keyring_writeauthinfo F_Keyring_writeauthinfo;
+struct F_Keyring_writeauthinfo
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	filename;
+	Keyring_Authinfo*	info;
+};
+void IPint_xor(void*);
+typedef struct F_IPint_xor F_IPint_xor;
+struct F_IPint_xor
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
+#define Keyring_PATH "$Keyring"
+#define Keyring_SHA1dlen 20
+#define Keyring_SHA224dlen 28
+#define Keyring_SHA256dlen 32
+#define Keyring_SHA384dlen 48
+#define Keyring_SHA512dlen 64
+#define Keyring_MD5dlen 16
+#define Keyring_MD4dlen 16
+#define Keyring_Encrypt 0
+#define Keyring_Decrypt 1
+#define Keyring_AESbsize 16
+#define Keyring_DESbsize 8
+#define Keyring_IDEAbsize 8
+#define Keyring_BFbsize 8
--- /dev/null
+++ b/libinterp/loadermod.h
@@ -1,0 +1,13 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Loadermodtab[]={
+	"compile",0x9af56bb1,Loader_compile,40,2,{0x0,0x80,},
+	"dnew",0x62a7cf80,Loader_dnew,40,2,{0x0,0x40,},
+	"ext",0xcd936c80,Loader_ext,48,2,{0x0,0x80,},
+	"ifetch",0xfb64be19,Loader_ifetch,40,2,{0x0,0x80,},
+	"link",0xe2473595,Loader_link,40,2,{0x0,0x80,},
+	"newmod",0x6de26f71,Loader_newmod,56,2,{0x0,0x98,},
+	"tdesc",0xb933ef75,Loader_tdesc,40,2,{0x0,0x80,},
+	"tnew",0xc1d58785,Loader_tnew,48,2,{0x0,0xa0,},
+	0
+};
+#define Loadermodlen	8
--- /dev/null
+++ b/libinterp/mathmod.h
@@ -1,0 +1,73 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Mathmodtab[]={
+	"FPcontrol",0x6584767b,Math_FPcontrol,40,0,{0},
+	"FPstatus",0x6584767b,Math_FPstatus,40,0,{0},
+	"acos",0xa1d1fe48,Math_acos,40,0,{0},
+	"acosh",0xa1d1fe48,Math_acosh,40,0,{0},
+	"asin",0xa1d1fe48,Math_asin,40,0,{0},
+	"asinh",0xa1d1fe48,Math_asinh,40,0,{0},
+	"atan",0xa1d1fe48,Math_atan,40,0,{0},
+	"atan2",0xf293f6cf,Math_atan2,48,0,{0},
+	"atanh",0xa1d1fe48,Math_atanh,40,0,{0},
+	"bits32real",0x40a58596,Math_bits32real,40,0,{0},
+	"bits64real",0x5463c72c,Math_bits64real,40,0,{0},
+	"cbrt",0xa1d1fe48,Math_cbrt,40,0,{0},
+	"ceil",0xa1d1fe48,Math_ceil,40,0,{0},
+	"copysign",0xf293f6cf,Math_copysign,48,0,{0},
+	"cos",0xa1d1fe48,Math_cos,40,0,{0},
+	"cosh",0xa1d1fe48,Math_cosh,40,0,{0},
+	"dot",0xfeca4db6,Math_dot,40,2,{0x0,0xc0,},
+	"erf",0xa1d1fe48,Math_erf,40,0,{0},
+	"erfc",0xa1d1fe48,Math_erfc,40,0,{0},
+	"exp",0xa1d1fe48,Math_exp,40,0,{0},
+	"expm1",0xa1d1fe48,Math_expm1,40,0,{0},
+	"export_int",0x3f1d94ee,Math_export_int,40,2,{0x0,0xc0,},
+	"export_real",0xd1fb0c8c,Math_export_real,40,2,{0x0,0xc0,},
+	"export_real32",0xd1fb0c8c,Math_export_real32,40,2,{0x0,0xc0,},
+	"fabs",0xa1d1fe48,Math_fabs,40,0,{0},
+	"fdim",0xf293f6cf,Math_fdim,48,0,{0},
+	"finite",0x7b2e5f52,Math_finite,40,0,{0},
+	"floor",0xa1d1fe48,Math_floor,40,0,{0},
+	"fmax",0xf293f6cf,Math_fmax,48,0,{0},
+	"fmin",0xf293f6cf,Math_fmin,48,0,{0},
+	"fmod",0xf293f6cf,Math_fmod,48,0,{0},
+	"gemm",0x53b8cd34,Math_gemm,96,3,{0x0,0x0,0xa2,},
+	"getFPcontrol",0x616977e8,Math_getFPcontrol,32,0,{0},
+	"getFPstatus",0x616977e8,Math_getFPstatus,32,0,{0},
+	"hypot",0xf293f6cf,Math_hypot,48,0,{0},
+	"iamax",0xa5fc2e4d,Math_iamax,40,2,{0x0,0x80,},
+	"ilogb",0x7b2e5f52,Math_ilogb,40,0,{0},
+	"import_int",0x3f1d94ee,Math_import_int,40,2,{0x0,0xc0,},
+	"import_real",0xd1fb0c8c,Math_import_real,40,2,{0x0,0xc0,},
+	"import_real32",0xd1fb0c8c,Math_import_real32,40,2,{0x0,0xc0,},
+	"isnan",0x7b2e5f52,Math_isnan,40,0,{0},
+	"j0",0xa1d1fe48,Math_j0,40,0,{0},
+	"j1",0xa1d1fe48,Math_j1,40,0,{0},
+	"jn",0xb61ffc5b,Math_jn,48,0,{0},
+	"lgamma",0x6e97c646,Math_lgamma,40,0,{0},
+	"log",0xa1d1fe48,Math_log,40,0,{0},
+	"log10",0xa1d1fe48,Math_log10,40,0,{0},
+	"log1p",0xa1d1fe48,Math_log1p,40,0,{0},
+	"modf",0x6e97c646,Math_modf,40,0,{0},
+	"nextafter",0xf293f6cf,Math_nextafter,48,0,{0},
+	"norm1",0x1629207e,Math_norm1,40,2,{0x0,0x80,},
+	"norm2",0x1629207e,Math_norm2,40,2,{0x0,0x80,},
+	"pow",0xf293f6cf,Math_pow,48,0,{0},
+	"pow10",0x40a58596,Math_pow10,40,0,{0},
+	"realbits32",0x7b2e5f52,Math_realbits32,40,0,{0},
+	"realbits64",0x9589d476,Math_realbits64,40,0,{0},
+	"remainder",0xf293f6cf,Math_remainder,48,0,{0},
+	"rint",0xa1d1fe48,Math_rint,40,0,{0},
+	"scalbn",0x64fa84ba,Math_scalbn,48,0,{0},
+	"sin",0xa1d1fe48,Math_sin,40,0,{0},
+	"sinh",0xa1d1fe48,Math_sinh,40,0,{0},
+	"sort",0xfc7c7b8,Math_sort,40,2,{0x0,0xc0,},
+	"sqrt",0xa1d1fe48,Math_sqrt,40,0,{0},
+	"tan",0xa1d1fe48,Math_tan,40,0,{0},
+	"tanh",0xa1d1fe48,Math_tanh,40,0,{0},
+	"y0",0xa1d1fe48,Math_y0,40,0,{0},
+	"y1",0xa1d1fe48,Math_y1,40,0,{0},
+	"yn",0xb61ffc5b,Math_yn,48,0,{0},
+	0
+};
+#define Mathmodlen	68
--- /dev/null
+++ b/libinterp/runt.h
@@ -1,0 +1,4002 @@
+typedef struct Sys_Qid Sys_Qid;
+typedef struct Sys_Dir Sys_Dir;
+typedef struct Sys_FD Sys_FD;
+typedef struct Sys_Connection Sys_Connection;
+typedef struct Sys_FileIO Sys_FileIO;
+typedef struct Draw_Chans Draw_Chans;
+typedef struct Draw_Point Draw_Point;
+typedef struct Draw_Rect Draw_Rect;
+typedef struct Draw_Image Draw_Image;
+typedef struct Draw_Display Draw_Display;
+typedef struct Draw_Font Draw_Font;
+typedef struct Draw_Screen Draw_Screen;
+typedef struct Draw_Pointer Draw_Pointer;
+typedef struct Draw_Context Draw_Context;
+typedef struct Draw_Wmcontext Draw_Wmcontext;
+typedef struct Prefab_Style Prefab_Style;
+typedef struct Prefab_Environ Prefab_Environ;
+typedef struct Prefab_Layout Prefab_Layout;
+typedef struct Prefab_Element Prefab_Element;
+typedef struct Prefab_Compound Prefab_Compound;
+typedef struct Tk_Toplevel Tk_Toplevel;
+typedef struct IPints_IPint IPints_IPint;
+typedef struct Crypt_DigestState Crypt_DigestState;
+typedef struct Crypt_AESstate Crypt_AESstate;
+typedef struct Crypt_DESstate Crypt_DESstate;
+typedef struct Crypt_IDEAstate Crypt_IDEAstate;
+typedef struct Crypt_RC4state Crypt_RC4state;
+typedef struct Crypt_BFstate Crypt_BFstate;
+typedef struct Crypt_PK Crypt_PK;
+typedef struct Crypt_SK Crypt_SK;
+typedef struct Crypt_PKsig Crypt_PKsig;
+typedef struct Loader_Inst Loader_Inst;
+typedef struct Loader_Typedesc Loader_Typedesc;
+typedef struct Loader_Link Loader_Link;
+typedef struct Loader_Niladt Loader_Niladt;
+typedef struct Freetype_Matrix Freetype_Matrix;
+typedef struct Freetype_Vector Freetype_Vector;
+typedef struct Freetype_Face Freetype_Face;
+typedef struct Freetype_Glyph Freetype_Glyph;
+struct Sys_Qid
+{
+	LONG	path;
+	WORD	vers;
+	WORD	qtype;
+};
+#define Sys_Qid_size 16
+#define Sys_Qid_map {0}
+struct Sys_Dir
+{
+	String*	name;
+	String*	uid;
+	String*	gid;
+	String*	muid;
+	Sys_Qid	qid;
+	WORD	mode;
+	WORD	atime;
+	WORD	mtime;
+	uchar	_pad44[4];
+	LONG	length;
+	WORD	dtype;
+	WORD	dev;
+};
+#define Sys_Dir_size 64
+#define Sys_Dir_map {0xf0,}
+struct Sys_FD
+{
+	WORD	fd;
+};
+#define Sys_FD_size 4
+#define Sys_FD_map {0}
+struct Sys_Connection
+{
+	Sys_FD*	dfd;
+	Sys_FD*	cfd;
+	String*	dir;
+};
+#define Sys_Connection_size 12
+#define Sys_Connection_map {0xe0,}
+typedef struct{ Array* t0; String* t1; } Sys_Rread;
+#define Sys_Rread_size 8
+#define Sys_Rread_map {0xc0,}
+typedef struct{ WORD t0; String* t1; } Sys_Rwrite;
+#define Sys_Rwrite_size 8
+#define Sys_Rwrite_map {0x40,}
+struct Sys_FileIO
+{
+	Channel*	read;
+	Channel*	write;
+};
+typedef struct{ WORD t0; WORD t1; WORD t2; Channel* t3; } Sys_FileIO_read;
+#define Sys_FileIO_read_size 16
+#define Sys_FileIO_read_map {0x10,}
+typedef struct{ WORD t0; Array* t1; WORD t2; Channel* t3; } Sys_FileIO_write;
+#define Sys_FileIO_write_size 16
+#define Sys_FileIO_write_map {0x50,}
+#define Sys_FileIO_size 8
+#define Sys_FileIO_map {0xc0,}
+struct Draw_Chans
+{
+	WORD	desc;
+};
+#define Draw_Chans_size 4
+#define Draw_Chans_map {0}
+struct Draw_Point
+{
+	WORD	x;
+	WORD	y;
+};
+#define Draw_Point_size 8
+#define Draw_Point_map {0}
+struct Draw_Rect
+{
+	Draw_Point	min;
+	Draw_Point	max;
+};
+#define Draw_Rect_size 16
+#define Draw_Rect_map {0}
+struct Draw_Image
+{
+	Draw_Rect	r;
+	Draw_Rect	clipr;
+	WORD	depth;
+	Draw_Chans	chans;
+	WORD	repl;
+	Draw_Display*	display;
+	Draw_Screen*	screen;
+	String*	iname;
+};
+#define Draw_Image_size 56
+#define Draw_Image_map {0x0,0x1c,}
+struct Draw_Display
+{
+	Draw_Image*	image;
+	Draw_Image*	white;
+	Draw_Image*	black;
+	Draw_Image*	opaque;
+	Draw_Image*	transparent;
+};
+#define Draw_Display_size 20
+#define Draw_Display_map {0xf8,}
+struct Draw_Font
+{
+	String*	name;
+	WORD	height;
+	WORD	ascent;
+	Draw_Display*	display;
+};
+#define Draw_Font_size 16
+#define Draw_Font_map {0x90,}
+struct Draw_Screen
+{
+	WORD	id;
+	Draw_Image*	image;
+	Draw_Image*	fill;
+	Draw_Display*	display;
+};
+#define Draw_Screen_size 16
+#define Draw_Screen_map {0x70,}
+struct Draw_Pointer
+{
+	WORD	buttons;
+	Draw_Point	xy;
+	WORD	msec;
+};
+#define Draw_Pointer_size 16
+#define Draw_Pointer_map {0}
+struct Draw_Context
+{
+	Draw_Display*	display;
+	Draw_Screen*	screen;
+	Channel*	wm;
+};
+typedef struct{ String* t0; Channel* t1; } Draw_Context_wm;
+#define Draw_Context_wm_size 8
+#define Draw_Context_wm_map {0xc0,}
+#define Draw_Context_size 12
+#define Draw_Context_map {0xe0,}
+struct Draw_Wmcontext
+{
+	Channel*	kbd;
+	Channel*	ptr;
+	Channel*	ctl;
+	Channel*	wctl;
+	Channel*	images;
+	Sys_FD*	connfd;
+	Draw_Context*	ctxt;
+};
+typedef WORD Draw_Wmcontext_kbd;
+#define Draw_Wmcontext_kbd_size 4
+#define Draw_Wmcontext_kbd_map {0}
+typedef Draw_Pointer* Draw_Wmcontext_ptr;
+#define Draw_Wmcontext_ptr_size 4
+#define Draw_Wmcontext_ptr_map {0x80,}
+typedef String* Draw_Wmcontext_ctl;
+#define Draw_Wmcontext_ctl_size 4
+#define Draw_Wmcontext_ctl_map {0x80,}
+typedef String* Draw_Wmcontext_wctl;
+#define Draw_Wmcontext_wctl_size 4
+#define Draw_Wmcontext_wctl_map {0x80,}
+typedef Draw_Image* Draw_Wmcontext_images;
+#define Draw_Wmcontext_images_size 4
+#define Draw_Wmcontext_images_map {0x80,}
+#define Draw_Wmcontext_size 28
+#define Draw_Wmcontext_map {0xfe,}
+struct Prefab_Style
+{
+	Draw_Font*	titlefont;
+	Draw_Font*	textfont;
+	Draw_Image*	elemcolor;
+	Draw_Image*	edgecolor;
+	Draw_Image*	titlecolor;
+	Draw_Image*	textcolor;
+	Draw_Image*	highlightcolor;
+};
+#define Prefab_Style_size 28
+#define Prefab_Style_map {0xfe,}
+struct Prefab_Environ
+{
+	Draw_Screen*	screen;
+	Prefab_Style*	style;
+};
+#define Prefab_Environ_size 8
+#define Prefab_Environ_map {0xc0,}
+struct Prefab_Layout
+{
+	Draw_Font*	font;
+	Draw_Image*	color;
+	String*	text;
+	Draw_Image*	icon;
+	Draw_Image*	mask;
+	String*	tag;
+};
+#define Prefab_Layout_size 24
+#define Prefab_Layout_map {0xfc,}
+struct Prefab_Element
+{
+	WORD	kind;
+	Draw_Rect	r;
+	Prefab_Environ*	environ;
+	String*	tag;
+	List*	kids;
+	String*	str;
+	Draw_Image*	mask;
+	Draw_Image*	image;
+	Draw_Font*	font;
+};
+#define Prefab_Element_size 48
+#define Prefab_Element_map {0x7,0xf0,}
+struct Prefab_Compound
+{
+	Draw_Image*	image;
+	Prefab_Environ*	environ;
+	Draw_Rect	r;
+	Prefab_Element*	title;
+	Prefab_Element*	contents;
+};
+#define Prefab_Compound_size 32
+#define Prefab_Compound_map {0xc3,}
+struct Tk_Toplevel
+{
+	Draw_Display*	display;
+	Channel*	wreq;
+	Draw_Image*	image;
+	Draw_Wmcontext*	ctxt;
+	Draw_Rect	screenr;
+};
+typedef String* Tk_Toplevel_wreq;
+#define Tk_Toplevel_wreq_size 4
+#define Tk_Toplevel_wreq_map {0x80,}
+#define Tk_Toplevel_size 32
+#define Tk_Toplevel_map {0xf0,}
+struct IPints_IPint
+{
+	WORD	x;
+};
+#define IPints_IPint_size 4
+#define IPints_IPint_map {0}
+struct Crypt_DigestState
+{
+	WORD	x;
+};
+#define Crypt_DigestState_size 4
+#define Crypt_DigestState_map {0}
+struct Crypt_AESstate
+{
+	WORD	x;
+};
+#define Crypt_AESstate_size 4
+#define Crypt_AESstate_map {0}
+struct Crypt_DESstate
+{
+	WORD	x;
+};
+#define Crypt_DESstate_size 4
+#define Crypt_DESstate_map {0}
+struct Crypt_IDEAstate
+{
+	WORD	x;
+};
+#define Crypt_IDEAstate_size 4
+#define Crypt_IDEAstate_map {0}
+struct Crypt_RC4state
+{
+	WORD	x;
+};
+#define Crypt_RC4state_size 4
+#define Crypt_RC4state_map {0}
+struct Crypt_BFstate
+{
+	WORD	x;
+};
+#define Crypt_BFstate_size 4
+#define Crypt_BFstate_map {0}
+#define Crypt_PK_RSA 0
+#define Crypt_PK_Elgamal 1
+#define Crypt_PK_DSA 2
+struct Crypt_PK
+{
+	int	pick;
+	union{
+		struct{
+			IPints_IPint*	n;
+			IPints_IPint*	ek;
+		} RSA;
+		struct{
+			IPints_IPint*	p;
+			IPints_IPint*	alpha;
+			IPints_IPint*	key;
+		} Elgamal;
+		struct{
+			IPints_IPint*	p;
+			IPints_IPint*	q;
+			IPints_IPint*	alpha;
+			IPints_IPint*	key;
+		} DSA;
+	} u;
+};
+#define Crypt_PK_RSA_size 12
+#define Crypt_PK_RSA_map {0x60,}
+#define Crypt_PK_Elgamal_size 16
+#define Crypt_PK_Elgamal_map {0x70,}
+#define Crypt_PK_DSA_size 20
+#define Crypt_PK_DSA_map {0x78,}
+#define Crypt_SK_RSA 0
+#define Crypt_SK_Elgamal 1
+#define Crypt_SK_DSA 2
+struct Crypt_SK
+{
+	int	pick;
+	union{
+		struct{
+			Crypt_PK*	pk;
+			IPints_IPint*	dk;
+			IPints_IPint*	p;
+			IPints_IPint*	q;
+			IPints_IPint*	kp;
+			IPints_IPint*	kq;
+			IPints_IPint*	c2;
+		} RSA;
+		struct{
+			Crypt_PK*	pk;
+			IPints_IPint*	secret;
+		} Elgamal;
+		struct{
+			Crypt_PK*	pk;
+			IPints_IPint*	secret;
+		} DSA;
+	} u;
+};
+#define Crypt_SK_RSA_size 32
+#define Crypt_SK_RSA_map {0x7f,}
+#define Crypt_SK_Elgamal_size 12
+#define Crypt_SK_Elgamal_map {0x60,}
+#define Crypt_SK_DSA_size 12
+#define Crypt_SK_DSA_map {0x60,}
+#define Crypt_PKsig_RSA 0
+#define Crypt_PKsig_Elgamal 1
+#define Crypt_PKsig_DSA 2
+struct Crypt_PKsig
+{
+	int	pick;
+	union{
+		struct{
+			IPints_IPint*	n;
+		} RSA;
+		struct{
+			IPints_IPint*	r;
+			IPints_IPint*	s;
+		} Elgamal;
+		struct{
+			IPints_IPint*	r;
+			IPints_IPint*	s;
+		} DSA;
+	} u;
+};
+#define Crypt_PKsig_RSA_size 8
+#define Crypt_PKsig_RSA_map {0x40,}
+#define Crypt_PKsig_Elgamal_size 12
+#define Crypt_PKsig_Elgamal_map {0x60,}
+#define Crypt_PKsig_DSA_size 12
+#define Crypt_PKsig_DSA_map {0x60,}
+struct Loader_Inst
+{
+	BYTE	op;
+	BYTE	addr;
+	uchar	_pad2[2];
+	WORD	src;
+	WORD	mid;
+	WORD	dst;
+};
+#define Loader_Inst_size 16
+#define Loader_Inst_map {0}
+struct Loader_Typedesc
+{
+	WORD	size;
+	Array*	map;
+};
+#define Loader_Typedesc_size 8
+#define Loader_Typedesc_map {0x40,}
+struct Loader_Link
+{
+	String*	name;
+	WORD	sig;
+	WORD	pc;
+	WORD	tdesc;
+};
+#define Loader_Link_size 16
+#define Loader_Link_map {0x80,}
+struct Loader_Niladt
+{
+	char	dummy[1];
+	uchar	_pad1[3];
+};
+#define Loader_Niladt_size 4
+#define Loader_Niladt_map {0}
+struct Freetype_Matrix
+{
+	WORD	a;
+	WORD	b;
+	WORD	c;
+	WORD	d;
+};
+#define Freetype_Matrix_size 16
+#define Freetype_Matrix_map {0}
+struct Freetype_Vector
+{
+	WORD	dx;
+	WORD	dy;
+};
+#define Freetype_Vector_size 8
+#define Freetype_Vector_map {0}
+struct Freetype_Face
+{
+	WORD	nfaces;
+	WORD	index;
+	WORD	style;
+	WORD	height;
+	WORD	ascent;
+	String*	familyname;
+	String*	stylename;
+};
+#define Freetype_Face_size 28
+#define Freetype_Face_map {0x6,}
+struct Freetype_Glyph
+{
+	WORD	top;
+	WORD	left;
+	WORD	height;
+	WORD	width;
+	Draw_Point	advance;
+	Array*	bitmap;
+};
+#define Freetype_Glyph_size 28
+#define Freetype_Glyph_map {0x2,}
+void Sys_announce(void*);
+typedef struct F_Sys_announce F_Sys_announce;
+struct F_Sys_announce
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	String*	addr;
+};
+void Sys_aprint(void*);
+typedef struct F_Sys_aprint F_Sys_aprint;
+struct F_Sys_aprint
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_bind(void*);
+typedef struct F_Sys_bind F_Sys_bind;
+struct F_Sys_bind
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	String*	on;
+	WORD	flags;
+};
+void Sys_byte2char(void*);
+typedef struct F_Sys_byte2char F_Sys_byte2char;
+struct F_Sys_byte2char
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; WORD t2; }*	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+};
+void Sys_char2byte(void*);
+typedef struct F_Sys_char2byte F_Sys_char2byte;
+struct F_Sys_char2byte
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	c;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_chdir(void*);
+typedef struct F_Sys_chdir F_Sys_chdir;
+struct F_Sys_chdir
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	path;
+};
+void Sys_create(void*);
+typedef struct F_Sys_create F_Sys_create;
+struct F_Sys_create
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	mode;
+	WORD	perm;
+};
+void Sys_dial(void*);
+typedef struct F_Sys_dial F_Sys_dial;
+struct F_Sys_dial
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	String*	addr;
+	String*	local;
+};
+void Sys_dirread(void*);
+typedef struct F_Sys_dirread F_Sys_dirread;
+struct F_Sys_dirread
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Array* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_dup(void*);
+typedef struct F_Sys_dup F_Sys_dup;
+struct F_Sys_dup
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	old;
+	WORD	new;
+};
+void Sys_export(void*);
+typedef struct F_Sys_export F_Sys_export;
+struct F_Sys_export
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	c;
+	String*	dir;
+	WORD	flag;
+};
+void Sys_fauth(void*);
+typedef struct F_Sys_fauth F_Sys_fauth;
+struct F_Sys_fauth
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	aname;
+};
+void Sys_fd2path(void*);
+typedef struct F_Sys_fd2path F_Sys_fd2path;
+struct F_Sys_fd2path
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_fildes(void*);
+typedef struct F_Sys_fildes F_Sys_fildes;
+struct F_Sys_fildes
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	WORD	fd;
+};
+void Sys_file2chan(void*);
+typedef struct F_Sys_file2chan F_Sys_file2chan;
+struct F_Sys_file2chan
+{
+	WORD	regs[NREG-1];
+	Sys_FileIO**	ret;
+	uchar	temps[12];
+	String*	dir;
+	String*	file;
+};
+void Sys_fprint(void*);
+typedef struct F_Sys_fprint F_Sys_fprint;
+struct F_Sys_fprint
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	String*	s;
+	WORD	vargs;
+};
+void Sys_fstat(void*);
+typedef struct F_Sys_fstat F_Sys_fstat;
+struct F_Sys_fstat
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; Sys_Dir t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_fversion(void*);
+typedef struct F_Sys_fversion F_Sys_fversion;
+struct F_Sys_fversion
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; String* t1; }*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	WORD	msize;
+	String*	version;
+};
+void Sys_fwstat(void*);
+typedef struct F_Sys_fwstat F_Sys_fwstat;
+struct F_Sys_fwstat
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	uchar	_pad36[4];
+	Sys_Dir	d;
+};
+void Sys_iounit(void*);
+typedef struct F_Sys_iounit F_Sys_iounit;
+struct F_Sys_iounit
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+};
+void Sys_listen(void*);
+typedef struct F_Sys_listen F_Sys_listen;
+struct F_Sys_listen
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; Sys_Connection t1; }*	ret;
+	uchar	temps[12];
+	Sys_Connection	c;
+};
+void Sys_millisec(void*);
+typedef struct F_Sys_millisec F_Sys_millisec;
+struct F_Sys_millisec
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+};
+void Sys_mount(void*);
+typedef struct F_Sys_mount F_Sys_mount;
+struct F_Sys_mount
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Sys_FD*	afd;
+	String*	on;
+	WORD	flags;
+	String*	spec;
+};
+void Sys_open(void*);
+typedef struct F_Sys_open F_Sys_open;
+struct F_Sys_open
+{
+	WORD	regs[NREG-1];
+	Sys_FD**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	mode;
+};
+void Sys_pctl(void*);
+typedef struct F_Sys_pctl F_Sys_pctl;
+struct F_Sys_pctl
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	flags;
+	List*	movefd;
+};
+void Sys_pipe(void*);
+typedef struct F_Sys_pipe F_Sys_pipe;
+struct F_Sys_pipe
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Array*	fds;
+};
+void Sys_pread(void*);
+typedef struct F_Sys_pread F_Sys_pread;
+struct F_Sys_pread
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+	uchar	_pad44[4];
+	LONG	off;
+};
+void Sys_print(void*);
+typedef struct F_Sys_print F_Sys_print;
+struct F_Sys_print
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_pwrite(void*);
+typedef struct F_Sys_pwrite F_Sys_pwrite;
+struct F_Sys_pwrite
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+	uchar	_pad44[4];
+	LONG	off;
+};
+void Sys_read(void*);
+typedef struct F_Sys_read F_Sys_read;
+struct F_Sys_read
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_readn(void*);
+typedef struct F_Sys_readn F_Sys_readn;
+struct F_Sys_readn
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_remove(void*);
+typedef struct F_Sys_remove F_Sys_remove;
+struct F_Sys_remove
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_seek(void*);
+typedef struct F_Sys_seek F_Sys_seek;
+struct F_Sys_seek
+{
+	WORD	regs[NREG-1];
+	LONG*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	uchar	_pad36[4];
+	LONG	off;
+	WORD	start;
+};
+void Sys_sleep(void*);
+typedef struct F_Sys_sleep F_Sys_sleep;
+struct F_Sys_sleep
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	period;
+};
+void Sys_sprint(void*);
+typedef struct F_Sys_sprint F_Sys_sprint;
+struct F_Sys_sprint
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	String*	s;
+	WORD	vargs;
+};
+void Sys_stat(void*);
+typedef struct F_Sys_stat F_Sys_stat;
+struct F_Sys_stat
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; Sys_Dir t1; }*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_stream(void*);
+typedef struct F_Sys_stream F_Sys_stream;
+struct F_Sys_stream
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	src;
+	Sys_FD*	dst;
+	WORD	bufsiz;
+};
+void Sys_tokenize(void*);
+typedef struct F_Sys_tokenize F_Sys_tokenize;
+struct F_Sys_tokenize
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; List* t1; }*	ret;
+	uchar	temps[12];
+	String*	s;
+	String*	delim;
+};
+void Sys_unmount(void*);
+typedef struct F_Sys_unmount F_Sys_unmount;
+struct F_Sys_unmount
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s1;
+	String*	s2;
+};
+void Sys_utfbytes(void*);
+typedef struct F_Sys_utfbytes F_Sys_utfbytes;
+struct F_Sys_utfbytes
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+};
+void Sys_werrstr(void*);
+typedef struct F_Sys_werrstr F_Sys_werrstr;
+struct F_Sys_werrstr
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Sys_write(void*);
+typedef struct F_Sys_write F_Sys_write;
+struct F_Sys_write
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Sys_FD*	fd;
+	Array*	buf;
+	WORD	n;
+};
+void Sys_wstat(void*);
+typedef struct F_Sys_wstat F_Sys_wstat;
+struct F_Sys_wstat
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	s;
+	uchar	_pad36[4];
+	Sys_Dir	d;
+};
+#define Sys_PATH "$Sys"
+#define Sys_Maxint 2147483647
+#define Sys_QTDIR 128
+#define Sys_QTAPPEND 64
+#define Sys_QTEXCL 32
+#define Sys_QTAUTH 8
+#define Sys_QTTMP 4
+#define Sys_QTFILE 0
+#define Sys_ATOMICIO 8192
+#define Sys_SEEKSTART 0
+#define Sys_SEEKRELA 1
+#define Sys_SEEKEND 2
+#define Sys_NAMEMAX 256
+#define Sys_ERRMAX 128
+#define Sys_WAITLEN 192
+#define Sys_OREAD 0
+#define Sys_OWRITE 1
+#define Sys_ORDWR 2
+#define Sys_OTRUNC 16
+#define Sys_ORCLOSE 64
+#define Sys_OEXCL 4096
+#define Sys_DMDIR -2147483648
+#define Sys_DMAPPEND 1073741824
+#define Sys_DMEXCL 536870912
+#define Sys_DMAUTH 134217728
+#define Sys_DMTMP 67108864
+#define Sys_MREPL 0
+#define Sys_MBEFORE 1
+#define Sys_MAFTER 2
+#define Sys_MCREATE 4
+#define Sys_MCACHE 16
+#define Sys_NEWFD 1
+#define Sys_FORKFD 2
+#define Sys_NEWNS 4
+#define Sys_FORKNS 8
+#define Sys_NEWPGRP 16
+#define Sys_NODEVS 32
+#define Sys_NEWENV 64
+#define Sys_FORKENV 128
+#define Sys_EXPWAIT 0
+#define Sys_EXPASYNC 1
+#define Sys_UTFmax 4
+#define Sys_UTFerror 65533
+#define Sys_Runemax 1114111
+#define Sys_Runemask 2097151
+void Rect_Xrect(void*);
+typedef struct F_Rect_Xrect F_Rect_Xrect;
+struct F_Rect_Xrect
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Rect	s;
+};
+void Point_add(void*);
+typedef struct F_Point_add F_Point_add;
+struct F_Point_add
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	Draw_Point	q;
+};
+void Rect_addpt(void*);
+typedef struct F_Rect_addpt F_Rect_addpt;
+struct F_Rect_addpt
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Point	p;
+};
+void Display_allocate(void*);
+typedef struct F_Display_allocate F_Display_allocate;
+struct F_Display_allocate
+{
+	WORD	regs[NREG-1];
+	Draw_Display**	ret;
+	uchar	temps[12];
+	String*	dev;
+};
+void Screen_allocate(void*);
+typedef struct F_Screen_allocate F_Screen_allocate;
+struct F_Screen_allocate
+{
+	WORD	regs[NREG-1];
+	Draw_Screen**	ret;
+	uchar	temps[12];
+	Draw_Image*	image;
+	Draw_Image*	fill;
+	WORD	public;
+};
+void Image_arc(void*);
+typedef struct F_Image_arc F_Image_arc;
+struct F_Image_arc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	WORD	thick;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	alpha;
+	WORD	phi;
+};
+void Image_arcop(void*);
+typedef struct F_Image_arcop F_Image_arcop;
+struct F_Image_arcop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	WORD	thick;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	alpha;
+	WORD	phi;
+	WORD	op;
+};
+void Image_arrow(void*);
+typedef struct F_Image_arrow F_Image_arrow;
+struct F_Image_arrow
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	a;
+	WORD	b;
+	WORD	c;
+};
+void Font_bbox(void*);
+typedef struct F_Font_bbox F_Font_bbox;
+struct F_Font_bbox
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Font*	f;
+	String*	str;
+};
+void Image_bezier(void*);
+typedef struct F_Image_bezier F_Image_bezier;
+struct F_Image_bezier
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	a;
+	Draw_Point	b;
+	Draw_Point	c;
+	Draw_Point	d;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_bezierop(void*);
+typedef struct F_Image_bezierop F_Image_bezierop;
+struct F_Image_bezierop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	a;
+	Draw_Point	b;
+	Draw_Point	c;
+	Draw_Point	d;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_bezspline(void*);
+typedef struct F_Image_bezspline F_Image_bezspline;
+struct F_Image_bezspline
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_bezsplineop(void*);
+typedef struct F_Image_bezsplineop F_Image_bezsplineop;
+struct F_Image_bezsplineop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_border(void*);
+typedef struct F_Image_border F_Image_border;
+struct F_Image_border
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	WORD	i;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_bottom(void*);
+typedef struct F_Image_bottom F_Image_bottom;
+struct F_Image_bottom
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	win;
+};
+void Screen_bottom(void*);
+typedef struct F_Screen_bottom F_Screen_bottom;
+struct F_Screen_bottom
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Screen*	screen;
+	Array*	wins;
+};
+void Font_build(void*);
+typedef struct F_Font_build F_Font_build;
+struct F_Font_build
+{
+	WORD	regs[NREG-1];
+	Draw_Font**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	name;
+	String*	desc;
+};
+void Draw_bytesperline(void*);
+typedef struct F_Draw_bytesperline F_Draw_bytesperline;
+struct F_Draw_bytesperline
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	WORD	d;
+};
+void Rect_canon(void*);
+typedef struct F_Rect_canon F_Rect_canon;
+struct F_Rect_canon
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+};
+void Rect_clip(void*);
+typedef struct F_Rect_clip F_Rect_clip;
+struct F_Rect_clip
+{
+	WORD	regs[NREG-1];
+	struct{ Draw_Rect t0; WORD t1; }*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Rect	s;
+};
+void Display_cmap2rgb(void*);
+typedef struct F_Display_cmap2rgb F_Display_cmap2rgb;
+struct F_Display_cmap2rgb
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; WORD t2; }*	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	c;
+};
+void Display_cmap2rgba(void*);
+typedef struct F_Display_cmap2rgba F_Display_cmap2rgba;
+struct F_Display_cmap2rgba
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	c;
+};
+void Display_color(void*);
+typedef struct F_Display_color F_Display_color;
+struct F_Display_color
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	color;
+};
+void Display_colormix(void*);
+typedef struct F_Display_colormix F_Display_colormix;
+struct F_Display_colormix
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	c1;
+	WORD	c2;
+};
+void Rect_combine(void*);
+typedef struct F_Rect_combine F_Rect_combine;
+struct F_Rect_combine
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Rect	s;
+};
+void Rect_contains(void*);
+typedef struct F_Rect_contains F_Rect_contains;
+struct F_Rect_contains
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Point	p;
+};
+void Chans_depth(void*);
+typedef struct F_Chans_depth F_Chans_depth;
+struct F_Chans_depth
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Chans	c;
+};
+void Point_div(void*);
+typedef struct F_Point_div F_Point_div;
+struct F_Point_div
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	WORD	i;
+};
+void Image_draw(void*);
+typedef struct F_Image_draw F_Image_draw;
+struct F_Image_draw
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	Draw_Image*	src;
+	Draw_Image*	matte;
+	Draw_Point	p;
+};
+void Image_drawop(void*);
+typedef struct F_Image_drawop F_Image_drawop;
+struct F_Image_drawop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	Draw_Image*	src;
+	Draw_Image*	matte;
+	Draw_Point	p;
+	WORD	op;
+};
+void Rect_dx(void*);
+typedef struct F_Rect_dx F_Rect_dx;
+struct F_Rect_dx
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+};
+void Rect_dy(void*);
+typedef struct F_Rect_dy F_Rect_dy;
+struct F_Rect_dy
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+};
+void Image_ellipse(void*);
+typedef struct F_Image_ellipse F_Image_ellipse;
+struct F_Image_ellipse
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	WORD	thick;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_ellipseop(void*);
+typedef struct F_Image_ellipseop F_Image_ellipseop;
+struct F_Image_ellipseop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	WORD	thick;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Chans_eq(void*);
+typedef struct F_Chans_eq F_Chans_eq;
+struct F_Chans_eq
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Chans	c;
+	Draw_Chans	d;
+};
+void Point_eq(void*);
+typedef struct F_Point_eq F_Point_eq;
+struct F_Point_eq
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	Draw_Point	q;
+};
+void Rect_eq(void*);
+typedef struct F_Rect_eq F_Rect_eq;
+struct F_Rect_eq
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Rect	s;
+};
+void Image_fillarc(void*);
+typedef struct F_Image_fillarc F_Image_fillarc;
+struct F_Image_fillarc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	alpha;
+	WORD	phi;
+};
+void Image_fillarcop(void*);
+typedef struct F_Image_fillarcop F_Image_fillarcop;
+struct F_Image_fillarcop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	alpha;
+	WORD	phi;
+	WORD	op;
+};
+void Image_fillbezier(void*);
+typedef struct F_Image_fillbezier F_Image_fillbezier;
+struct F_Image_fillbezier
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	a;
+	Draw_Point	b;
+	Draw_Point	c;
+	Draw_Point	d;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_fillbezierop(void*);
+typedef struct F_Image_fillbezierop F_Image_fillbezierop;
+struct F_Image_fillbezierop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	a;
+	Draw_Point	b;
+	Draw_Point	c;
+	Draw_Point	d;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_fillbezspline(void*);
+typedef struct F_Image_fillbezspline F_Image_fillbezspline;
+struct F_Image_fillbezspline
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_fillbezsplineop(void*);
+typedef struct F_Image_fillbezsplineop F_Image_fillbezsplineop;
+struct F_Image_fillbezsplineop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_fillellipse(void*);
+typedef struct F_Image_fillellipse F_Image_fillellipse;
+struct F_Image_fillellipse
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_fillellipseop(void*);
+typedef struct F_Image_fillellipseop F_Image_fillellipseop;
+struct F_Image_fillellipseop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	c;
+	WORD	a;
+	WORD	b;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_fillpoly(void*);
+typedef struct F_Image_fillpoly F_Image_fillpoly;
+struct F_Image_fillpoly
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_fillpolyop(void*);
+typedef struct F_Image_fillpolyop F_Image_fillpolyop;
+struct F_Image_fillpolyop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	wind;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Image_flush(void*);
+typedef struct F_Image_flush F_Image_flush;
+struct F_Image_flush
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	win;
+	WORD	func;
+};
+void Image_gendraw(void*);
+typedef struct F_Image_gendraw F_Image_gendraw;
+struct F_Image_gendraw
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	Draw_Image*	src;
+	Draw_Point	p0;
+	Draw_Image*	matte;
+	Draw_Point	p1;
+};
+void Image_gendrawop(void*);
+typedef struct F_Image_gendrawop F_Image_gendrawop;
+struct F_Image_gendrawop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	Draw_Image*	src;
+	Draw_Point	p0;
+	Draw_Image*	matte;
+	Draw_Point	p1;
+	WORD	op;
+};
+void Display_getwindow(void*);
+typedef struct F_Display_getwindow F_Display_getwindow;
+struct F_Display_getwindow
+{
+	WORD	regs[NREG-1];
+	struct{ Draw_Screen* t0; Draw_Image* t1; }*	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	winname;
+	Draw_Screen*	screen;
+	Draw_Image*	image;
+	WORD	backup;
+};
+void Draw_icossin(void*);
+typedef struct F_Draw_icossin F_Draw_icossin;
+struct F_Draw_icossin
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; }*	ret;
+	uchar	temps[12];
+	WORD	deg;
+};
+void Draw_icossin2(void*);
+typedef struct F_Draw_icossin2 F_Draw_icossin2;
+struct F_Draw_icossin2
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; }*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+};
+void Point_in(void*);
+typedef struct F_Point_in F_Point_in;
+struct F_Point_in
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	Draw_Rect	r;
+};
+void Rect_inrect(void*);
+typedef struct F_Rect_inrect F_Rect_inrect;
+struct F_Rect_inrect
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Rect	s;
+};
+void Rect_inset(void*);
+typedef struct F_Rect_inset F_Rect_inset;
+struct F_Rect_inset
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	WORD	n;
+};
+void Image_line(void*);
+typedef struct F_Image_line F_Image_line;
+struct F_Image_line
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p0;
+	Draw_Point	p1;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_lineop(void*);
+typedef struct F_Image_lineop F_Image_lineop;
+struct F_Image_lineop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p0;
+	Draw_Point	p1;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Chans_mk(void*);
+typedef struct F_Chans_mk F_Chans_mk;
+struct F_Chans_mk
+{
+	WORD	regs[NREG-1];
+	Draw_Chans*	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Point_mul(void*);
+typedef struct F_Point_mul F_Point_mul;
+struct F_Point_mul
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	WORD	i;
+};
+void Image_name(void*);
+typedef struct F_Image_name F_Image_name;
+struct F_Image_name
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Image*	src;
+	String*	name;
+	WORD	in;
+};
+void Display_namedimage(void*);
+typedef struct F_Display_namedimage F_Display_namedimage;
+struct F_Display_namedimage
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	name;
+};
+void Display_newimage(void*);
+typedef struct F_Display_newimage F_Display_newimage;
+struct F_Display_newimage
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	Draw_Rect	r;
+	Draw_Chans	chans;
+	WORD	repl;
+	WORD	color;
+};
+void Screen_newwindow(void*);
+typedef struct F_Screen_newwindow F_Screen_newwindow;
+struct F_Screen_newwindow
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Screen*	screen;
+	Draw_Rect	r;
+	WORD	backing;
+	WORD	color;
+};
+void Display_open(void*);
+typedef struct F_Display_open F_Display_open;
+struct F_Display_open
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	name;
+};
+void Font_open(void*);
+typedef struct F_Font_open F_Font_open;
+struct F_Font_open
+{
+	WORD	regs[NREG-1];
+	Draw_Font**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	name;
+};
+void Image_origin(void*);
+typedef struct F_Image_origin F_Image_origin;
+struct F_Image_origin
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Image*	win;
+	Draw_Point	log;
+	Draw_Point	scr;
+};
+void Image_poly(void*);
+typedef struct F_Image_poly F_Image_poly;
+struct F_Image_poly
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+};
+void Image_polyop(void*);
+typedef struct F_Image_polyop F_Image_polyop;
+struct F_Image_polyop
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Array*	p;
+	WORD	end0;
+	WORD	end1;
+	WORD	radius;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	WORD	op;
+};
+void Display_publicscreen(void*);
+typedef struct F_Display_publicscreen F_Display_publicscreen;
+struct F_Display_publicscreen
+{
+	WORD	regs[NREG-1];
+	Draw_Screen**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	id;
+};
+void Display_readimage(void*);
+typedef struct F_Display_readimage F_Display_readimage;
+struct F_Display_readimage
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	Sys_FD*	fd;
+};
+void Image_readpixels(void*);
+typedef struct F_Image_readpixels F_Image_readpixels;
+struct F_Image_readpixels
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Image*	src;
+	Draw_Rect	r;
+	Array*	data;
+};
+void Display_rgb(void*);
+typedef struct F_Display_rgb F_Display_rgb;
+struct F_Display_rgb
+{
+	WORD	regs[NREG-1];
+	Draw_Image**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	r;
+	WORD	g;
+	WORD	b;
+};
+void Display_rgb2cmap(void*);
+typedef struct F_Display_rgb2cmap F_Display_rgb2cmap;
+struct F_Display_rgb2cmap
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	WORD	r;
+	WORD	g;
+	WORD	b;
+};
+void Draw_setalpha(void*);
+typedef struct F_Draw_setalpha F_Draw_setalpha;
+struct F_Draw_setalpha
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	c;
+	WORD	a;
+};
+void Rect_size(void*);
+typedef struct F_Rect_size F_Rect_size;
+struct F_Rect_size
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+};
+void Display_startrefresh(void*);
+typedef struct F_Display_startrefresh F_Display_startrefresh;
+struct F_Display_startrefresh
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Display*	d;
+};
+void Point_sub(void*);
+typedef struct F_Point_sub F_Point_sub;
+struct F_Point_sub
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Point	p;
+	Draw_Point	q;
+};
+void Rect_subpt(void*);
+typedef struct F_Rect_subpt F_Rect_subpt;
+struct F_Rect_subpt
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Draw_Rect	r;
+	Draw_Point	p;
+};
+void Chans_text(void*);
+typedef struct F_Chans_text F_Chans_text;
+struct F_Chans_text
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Draw_Chans	c;
+};
+void Image_text(void*);
+typedef struct F_Image_text F_Image_text;
+struct F_Image_text
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	Draw_Font*	font;
+	String*	str;
+};
+void Image_textbg(void*);
+typedef struct F_Image_textbg F_Image_textbg;
+struct F_Image_textbg
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	Draw_Font*	font;
+	String*	str;
+	Draw_Image*	bg;
+	Draw_Point	bgp;
+};
+void Image_textbgop(void*);
+typedef struct F_Image_textbgop F_Image_textbgop;
+struct F_Image_textbgop
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	Draw_Font*	font;
+	String*	str;
+	Draw_Image*	bg;
+	Draw_Point	bgp;
+	WORD	op;
+};
+void Image_textop(void*);
+typedef struct F_Image_textop F_Image_textop;
+struct F_Image_textop
+{
+	WORD	regs[NREG-1];
+	Draw_Point*	ret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Point	p;
+	Draw_Image*	src;
+	Draw_Point	sp;
+	Draw_Font*	font;
+	String*	str;
+	WORD	op;
+};
+void Image_top(void*);
+typedef struct F_Image_top F_Image_top;
+struct F_Image_top
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Image*	win;
+};
+void Screen_top(void*);
+typedef struct F_Screen_top F_Screen_top;
+struct F_Screen_top
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Draw_Screen*	screen;
+	Array*	wins;
+};
+void Font_width(void*);
+typedef struct F_Font_width F_Font_width;
+struct F_Font_width
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Font*	f;
+	String*	str;
+};
+void Display_writeimage(void*);
+typedef struct F_Display_writeimage F_Display_writeimage;
+struct F_Display_writeimage
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	Sys_FD*	fd;
+	Draw_Image*	i;
+};
+void Image_writepixels(void*);
+typedef struct F_Image_writepixels F_Image_writepixels;
+struct F_Image_writepixels
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Draw_Image*	dst;
+	Draw_Rect	r;
+	Array*	data;
+};
+#define Draw_PATH "$Draw"
+#define Draw_Opaque -1
+#define Draw_Transparent 0
+#define Draw_Black 255
+#define Draw_White -1
+#define Draw_Red -16776961
+#define Draw_Green 16711935
+#define Draw_Blue 65535
+#define Draw_Cyan 16777215
+#define Draw_Magenta -16711681
+#define Draw_Yellow -65281
+#define Draw_Grey -286331137
+#define Draw_Paleyellow -21761
+#define Draw_Darkyellow -286351617
+#define Draw_Darkgreen 1149781247
+#define Draw_Palegreen -1426085121
+#define Draw_Medgreen -1999861505
+#define Draw_Darkblue 22015
+#define Draw_Palebluegreen -1426063361
+#define Draw_Paleblue 48127
+#define Draw_Bluegreen 8947967
+#define Draw_Greygreen 1437248255
+#define Draw_Palegreygreen -1628508417
+#define Draw_Yellowgreen -1718006529
+#define Draw_Medblue 39423
+#define Draw_Greyblue 6142975
+#define Draw_Palegreyblue 1234427391
+#define Draw_Purpleblue -2004300545
+#define Draw_Notacolor -256
+#define Draw_Nofill -256
+#define Draw_Endsquare 0
+#define Draw_Enddisc 1
+#define Draw_Endarrow 2
+#define Draw_Flushoff 0
+#define Draw_Flushon 1
+#define Draw_Flushnow 2
+#define Draw_Refbackup 0
+#define Draw_Refnone 1
+#define Draw_SinD 8
+#define Draw_DinS 4
+#define Draw_SoutD 2
+#define Draw_DoutS 1
+#define Draw_S 10
+#define Draw_SoverD 11
+#define Draw_SatopD 9
+#define Draw_SxorD 3
+#define Draw_D 5
+#define Draw_DoverS 7
+#define Draw_DatopS 6
+#define Draw_DxorS 3
+#define Draw_Clear 0
+#define Draw_CRed 0
+#define Draw_CGreen 1
+#define Draw_CBlue 2
+#define Draw_CGrey 3
+#define Draw_CAlpha 4
+#define Draw_CMap 5
+#define Draw_CIgnore 6
+void Element_adjust(void*);
+typedef struct F_Element_adjust F_Element_adjust;
+struct F_Element_adjust
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Element*	elem;
+	WORD	equal;
+	WORD	dir;
+};
+void Element_append(void*);
+typedef struct F_Element_append F_Element_append;
+struct F_Element_append
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Prefab_Element*	elist;
+	Prefab_Element*	elem;
+};
+void Compound_box(void*);
+typedef struct F_Compound_box F_Compound_box;
+struct F_Compound_box
+{
+	WORD	regs[NREG-1];
+	Prefab_Compound**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Point	p;
+	Prefab_Element*	title;
+	Prefab_Element*	elist;
+};
+void Element_clip(void*);
+typedef struct F_Element_clip F_Element_clip;
+struct F_Element_clip
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Element*	elem;
+	Draw_Rect	r;
+};
+void Compound_draw(void*);
+typedef struct F_Compound_draw F_Compound_draw;
+struct F_Compound_draw
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+};
+void Element_elist(void*);
+typedef struct F_Element_elist F_Element_elist;
+struct F_Element_elist
+{
+	WORD	regs[NREG-1];
+	Prefab_Element**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Prefab_Element*	elem;
+	WORD	kind;
+};
+void Compound_highlight(void*);
+typedef struct F_Compound_highlight F_Compound_highlight;
+struct F_Compound_highlight
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Prefab_Element*	elem;
+	WORD	on;
+};
+void Element_icon(void*);
+typedef struct F_Element_icon F_Element_icon;
+struct F_Element_icon
+{
+	WORD	regs[NREG-1];
+	Prefab_Element**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Rect	r;
+	Draw_Image*	icon;
+	Draw_Image*	mask;
+};
+void Compound_iconbox(void*);
+typedef struct F_Compound_iconbox F_Compound_iconbox;
+struct F_Compound_iconbox
+{
+	WORD	regs[NREG-1];
+	Prefab_Compound**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Point	p;
+	String*	title;
+	Draw_Image*	icon;
+	Draw_Image*	mask;
+};
+void Element_layout(void*);
+typedef struct F_Element_layout F_Element_layout;
+struct F_Element_layout
+{
+	WORD	regs[NREG-1];
+	Prefab_Element**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	List*	lay;
+	Draw_Rect	r;
+	WORD	kind;
+};
+void Compound_layoutbox(void*);
+typedef struct F_Compound_layoutbox F_Compound_layoutbox;
+struct F_Compound_layoutbox
+{
+	WORD	regs[NREG-1];
+	Prefab_Compound**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Rect	r;
+	String*	title;
+	List*	lay;
+};
+void Compound_redraw(void*);
+typedef struct F_Compound_redraw F_Compound_redraw;
+struct F_Compound_redraw
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Draw_Rect	r;
+};
+void Element_scroll(void*);
+typedef struct F_Element_scroll F_Element_scroll;
+struct F_Element_scroll
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Element*	elem;
+	Draw_Point	d;
+};
+void Compound_scroll(void*);
+typedef struct F_Compound_scroll F_Compound_scroll;
+struct F_Compound_scroll
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Prefab_Element*	elem;
+	Draw_Point	d;
+};
+void Compound_select(void*);
+typedef struct F_Compound_select F_Compound_select;
+struct F_Compound_select
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; Prefab_Element* t2; }*	ret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Prefab_Element*	elem;
+	WORD	i;
+	Channel*	c;
+};
+void Element_separator(void*);
+typedef struct F_Element_separator F_Element_separator;
+struct F_Element_separator
+{
+	WORD	regs[NREG-1];
+	Prefab_Element**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Rect	r;
+	Draw_Image*	icon;
+	Draw_Image*	mask;
+};
+void Element_show(void*);
+typedef struct F_Element_show F_Element_show;
+struct F_Element_show
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Prefab_Element*	elist;
+	Prefab_Element*	elem;
+};
+void Compound_show(void*);
+typedef struct F_Compound_show F_Compound_show;
+struct F_Compound_show
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Prefab_Element*	elem;
+};
+void Compound_tagselect(void*);
+typedef struct F_Compound_tagselect F_Compound_tagselect;
+struct F_Compound_tagselect
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; WORD t1; Prefab_Element* t2; }*	ret;
+	uchar	temps[12];
+	Prefab_Compound*	comp;
+	Prefab_Element*	elem;
+	WORD	i;
+	Channel*	c;
+};
+void Element_text(void*);
+typedef struct F_Element_text F_Element_text;
+struct F_Element_text
+{
+	WORD	regs[NREG-1];
+	Prefab_Element**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	String*	text;
+	Draw_Rect	r;
+	WORD	kind;
+};
+void Compound_textbox(void*);
+typedef struct F_Compound_textbox F_Compound_textbox;
+struct F_Compound_textbox
+{
+	WORD	regs[NREG-1];
+	Prefab_Compound**	ret;
+	uchar	temps[12];
+	Prefab_Environ*	env;
+	Draw_Rect	r;
+	String*	title;
+	String*	text;
+};
+void Element_translate(void*);
+typedef struct F_Element_translate F_Element_translate;
+struct F_Element_translate
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Prefab_Element*	elem;
+	Draw_Point	d;
+};
+#define Prefab_PATH "$Prefab"
+#define Prefab_EIcon 0
+#define Prefab_EText 1
+#define Prefab_ETitle 2
+#define Prefab_EHorizontal 3
+#define Prefab_EVertical 4
+#define Prefab_ESeparator 5
+#define Prefab_Adjpack 10
+#define Prefab_Adjequal 11
+#define Prefab_Adjfill 12
+#define Prefab_Adjleft 20
+#define Prefab_Adjup 20
+#define Prefab_Adjcenter 21
+#define Prefab_Adjright 22
+#define Prefab_Adjdown 22
+void Tk_cmd(void*);
+typedef struct F_Tk_cmd F_Tk_cmd;
+struct F_Tk_cmd
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	String*	arg;
+};
+void Tk_color(void*);
+typedef struct F_Tk_color F_Tk_color;
+struct F_Tk_color
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	String*	col;
+};
+void Tk_getimage(void*);
+typedef struct F_Tk_getimage F_Tk_getimage;
+struct F_Tk_getimage
+{
+	WORD	regs[NREG-1];
+	struct{ Draw_Image* t0; Draw_Image* t1; String* t2; }*	ret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	String*	name;
+};
+void Tk_keyboard(void*);
+typedef struct F_Tk_keyboard F_Tk_keyboard;
+struct F_Tk_keyboard
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	WORD	key;
+};
+void Tk_namechan(void*);
+typedef struct F_Tk_namechan F_Tk_namechan;
+struct F_Tk_namechan
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	Channel*	c;
+	String*	n;
+};
+void Tk_pointer(void*);
+typedef struct F_Tk_pointer F_Tk_pointer;
+struct F_Tk_pointer
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	Draw_Pointer	p;
+};
+void Tk_putimage(void*);
+typedef struct F_Tk_putimage F_Tk_putimage;
+struct F_Tk_putimage
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	String*	name;
+	Draw_Image*	i;
+	Draw_Image*	m;
+};
+void Tk_quote(void*);
+typedef struct F_Tk_quote F_Tk_quote;
+struct F_Tk_quote
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	String*	s;
+};
+void Tk_rect(void*);
+typedef struct F_Tk_rect F_Tk_rect;
+struct F_Tk_rect
+{
+	WORD	regs[NREG-1];
+	Draw_Rect*	ret;
+	uchar	temps[12];
+	Tk_Toplevel*	t;
+	String*	name;
+	WORD	flags;
+};
+void Tk_toplevel(void*);
+typedef struct F_Tk_toplevel F_Tk_toplevel;
+struct F_Tk_toplevel
+{
+	WORD	regs[NREG-1];
+	Tk_Toplevel**	ret;
+	uchar	temps[12];
+	Draw_Display*	d;
+	String*	arg;
+};
+#define Tk_PATH "$Tk"
+#define Tk_Border 1
+#define Tk_Required 2
+#define Tk_Local 4
+void Math_FPcontrol(void*);
+typedef struct F_Math_FPcontrol F_Math_FPcontrol;
+struct F_Math_FPcontrol
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	r;
+	WORD	mask;
+};
+void Math_FPstatus(void*);
+typedef struct F_Math_FPstatus F_Math_FPstatus;
+struct F_Math_FPstatus
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	WORD	r;
+	WORD	mask;
+};
+void Math_acos(void*);
+typedef struct F_Math_acos F_Math_acos;
+struct F_Math_acos
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_acosh(void*);
+typedef struct F_Math_acosh F_Math_acosh;
+struct F_Math_acosh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_asin(void*);
+typedef struct F_Math_asin F_Math_asin;
+struct F_Math_asin
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_asinh(void*);
+typedef struct F_Math_asinh F_Math_asinh;
+struct F_Math_asinh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_atan(void*);
+typedef struct F_Math_atan F_Math_atan;
+struct F_Math_atan
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_atan2(void*);
+typedef struct F_Math_atan2 F_Math_atan2;
+struct F_Math_atan2
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	y;
+	REAL	x;
+};
+void Math_atanh(void*);
+typedef struct F_Math_atanh F_Math_atanh;
+struct F_Math_atanh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_bits32real(void*);
+typedef struct F_Math_bits32real F_Math_bits32real;
+struct F_Math_bits32real
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	WORD	b;
+};
+void Math_bits64real(void*);
+typedef struct F_Math_bits64real F_Math_bits64real;
+struct F_Math_bits64real
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	LONG	b;
+};
+void Math_cbrt(void*);
+typedef struct F_Math_cbrt F_Math_cbrt;
+struct F_Math_cbrt
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_ceil(void*);
+typedef struct F_Math_ceil F_Math_ceil;
+struct F_Math_ceil
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_copysign(void*);
+typedef struct F_Math_copysign F_Math_copysign;
+struct F_Math_copysign
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	s;
+};
+void Math_cos(void*);
+typedef struct F_Math_cos F_Math_cos;
+struct F_Math_cos
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_cosh(void*);
+typedef struct F_Math_cosh F_Math_cosh;
+struct F_Math_cosh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_dot(void*);
+typedef struct F_Math_dot F_Math_dot;
+struct F_Math_dot
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	Array*	x;
+	Array*	y;
+};
+void Math_erf(void*);
+typedef struct F_Math_erf F_Math_erf;
+struct F_Math_erf
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_erfc(void*);
+typedef struct F_Math_erfc F_Math_erfc;
+struct F_Math_erfc
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_exp(void*);
+typedef struct F_Math_exp F_Math_exp;
+struct F_Math_exp
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_expm1(void*);
+typedef struct F_Math_expm1 F_Math_expm1;
+struct F_Math_expm1
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_export_int(void*);
+typedef struct F_Math_export_int F_Math_export_int;
+struct F_Math_export_int
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_export_real(void*);
+typedef struct F_Math_export_real F_Math_export_real;
+struct F_Math_export_real
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_export_real32(void*);
+typedef struct F_Math_export_real32 F_Math_export_real32;
+struct F_Math_export_real32
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_fabs(void*);
+typedef struct F_Math_fabs F_Math_fabs;
+struct F_Math_fabs
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_fdim(void*);
+typedef struct F_Math_fdim F_Math_fdim;
+struct F_Math_fdim
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_finite(void*);
+typedef struct F_Math_finite F_Math_finite;
+struct F_Math_finite
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_floor(void*);
+typedef struct F_Math_floor F_Math_floor;
+struct F_Math_floor
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_fmax(void*);
+typedef struct F_Math_fmax F_Math_fmax;
+struct F_Math_fmax
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_fmin(void*);
+typedef struct F_Math_fmin F_Math_fmin;
+struct F_Math_fmin
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_fmod(void*);
+typedef struct F_Math_fmod F_Math_fmod;
+struct F_Math_fmod
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_gemm(void*);
+typedef struct F_Math_gemm F_Math_gemm;
+struct F_Math_gemm
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	WORD	transa;
+	WORD	transb;
+	WORD	m;
+	WORD	n;
+	WORD	k;
+	uchar	_pad52[4];
+	REAL	alpha;
+	Array*	a;
+	WORD	lda;
+	Array*	b;
+	WORD	ldb;
+	REAL	beta;
+	Array*	c;
+	WORD	ldc;
+};
+void Math_getFPcontrol(void*);
+typedef struct F_Math_getFPcontrol F_Math_getFPcontrol;
+struct F_Math_getFPcontrol
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+};
+void Math_getFPstatus(void*);
+typedef struct F_Math_getFPstatus F_Math_getFPstatus;
+struct F_Math_getFPstatus
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+};
+void Math_hypot(void*);
+typedef struct F_Math_hypot F_Math_hypot;
+struct F_Math_hypot
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_iamax(void*);
+typedef struct F_Math_iamax F_Math_iamax;
+struct F_Math_iamax
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Array*	x;
+};
+void Math_ilogb(void*);
+typedef struct F_Math_ilogb F_Math_ilogb;
+struct F_Math_ilogb
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_import_int(void*);
+typedef struct F_Math_import_int F_Math_import_int;
+struct F_Math_import_int
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_import_real(void*);
+typedef struct F_Math_import_real F_Math_import_real;
+struct F_Math_import_real
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_import_real32(void*);
+typedef struct F_Math_import_real32 F_Math_import_real32;
+struct F_Math_import_real32
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	b;
+	Array*	x;
+};
+void Math_isnan(void*);
+typedef struct F_Math_isnan F_Math_isnan;
+struct F_Math_isnan
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_j0(void*);
+typedef struct F_Math_j0 F_Math_j0;
+struct F_Math_j0
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_j1(void*);
+typedef struct F_Math_j1 F_Math_j1;
+struct F_Math_j1
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_jn(void*);
+typedef struct F_Math_jn F_Math_jn;
+struct F_Math_jn
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	WORD	n;
+	uchar	_pad36[4];
+	REAL	x;
+};
+void Math_lgamma(void*);
+typedef struct F_Math_lgamma F_Math_lgamma;
+struct F_Math_lgamma
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; REAL t1; }*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_log(void*);
+typedef struct F_Math_log F_Math_log;
+struct F_Math_log
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_log10(void*);
+typedef struct F_Math_log10 F_Math_log10;
+struct F_Math_log10
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_log1p(void*);
+typedef struct F_Math_log1p F_Math_log1p;
+struct F_Math_log1p
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_modf(void*);
+typedef struct F_Math_modf F_Math_modf;
+struct F_Math_modf
+{
+	WORD	regs[NREG-1];
+	struct{ WORD t0; uchar	_pad4[4]; REAL t1; }*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_nextafter(void*);
+typedef struct F_Math_nextafter F_Math_nextafter;
+struct F_Math_nextafter
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_norm1(void*);
+typedef struct F_Math_norm1 F_Math_norm1;
+struct F_Math_norm1
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	Array*	x;
+};
+void Math_norm2(void*);
+typedef struct F_Math_norm2 F_Math_norm2;
+struct F_Math_norm2
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	Array*	x;
+};
+void Math_pow(void*);
+typedef struct F_Math_pow F_Math_pow;
+struct F_Math_pow
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	y;
+};
+void Math_pow10(void*);
+typedef struct F_Math_pow10 F_Math_pow10;
+struct F_Math_pow10
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	WORD	p;
+};
+void Math_realbits32(void*);
+typedef struct F_Math_realbits32 F_Math_realbits32;
+struct F_Math_realbits32
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_realbits64(void*);
+typedef struct F_Math_realbits64 F_Math_realbits64;
+struct F_Math_realbits64
+{
+	WORD	regs[NREG-1];
+	LONG*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_remainder(void*);
+typedef struct F_Math_remainder F_Math_remainder;
+struct F_Math_remainder
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	REAL	p;
+};
+void Math_rint(void*);
+typedef struct F_Math_rint F_Math_rint;
+struct F_Math_rint
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_scalbn(void*);
+typedef struct F_Math_scalbn F_Math_scalbn;
+struct F_Math_scalbn
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+	WORD	n;
+};
+void Math_sin(void*);
+typedef struct F_Math_sin F_Math_sin;
+struct F_Math_sin
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_sinh(void*);
+typedef struct F_Math_sinh F_Math_sinh;
+struct F_Math_sinh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_sort(void*);
+typedef struct F_Math_sort F_Math_sort;
+struct F_Math_sort
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Array*	x;
+	Array*	pi;
+};
+void Math_sqrt(void*);
+typedef struct F_Math_sqrt F_Math_sqrt;
+struct F_Math_sqrt
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_tan(void*);
+typedef struct F_Math_tan F_Math_tan;
+struct F_Math_tan
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_tanh(void*);
+typedef struct F_Math_tanh F_Math_tanh;
+struct F_Math_tanh
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_y0(void*);
+typedef struct F_Math_y0 F_Math_y0;
+struct F_Math_y0
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_y1(void*);
+typedef struct F_Math_y1 F_Math_y1;
+struct F_Math_y1
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	REAL	x;
+};
+void Math_yn(void*);
+typedef struct F_Math_yn F_Math_yn;
+struct F_Math_yn
+{
+	WORD	regs[NREG-1];
+	REAL*	ret;
+	uchar	temps[12];
+	WORD	n;
+	uchar	_pad36[4];
+	REAL	x;
+};
+#define Math_PATH "$Math"
+#define Math_Infinity Infinity
+#define Math_NaN NaN
+#define Math_MachEps 2.220446049250313e-16
+#define Math_Pi 3.1415927410125732
+#define Math_Degree .01745329238474369
+#define Math_INVAL 1
+#define Math_ZDIV 2
+#define Math_OVFL 4
+#define Math_UNFL 8
+#define Math_INEX 16
+#define Math_RND_NR 0
+#define Math_RND_NINF 256
+#define Math_RND_PINF 512
+#define Math_RND_Z 768
+#define Math_RND_MASK 768
+void IPints_DSAprimes(void*);
+typedef struct F_IPints_DSAprimes F_IPints_DSAprimes;
+struct F_IPints_DSAprimes
+{
+	WORD	regs[NREG-1];
+	struct{ IPints_IPint* t0; IPints_IPint* t1; Array* t2; }*	ret;
+	uchar	temps[12];
+};
+void IPint_add(void*);
+typedef struct F_IPint_add F_IPint_add;
+struct F_IPint_add
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_and(void*);
+typedef struct F_IPint_and F_IPint_and;
+struct F_IPint_and
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_b64toip(void*);
+typedef struct F_IPint_b64toip F_IPint_b64toip;
+struct F_IPint_b64toip
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	String*	str;
+};
+void IPint_bebytestoip(void*);
+typedef struct F_IPint_bebytestoip F_IPint_bebytestoip;
+struct F_IPint_bebytestoip
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	Array*	mag;
+};
+void IPint_bits(void*);
+typedef struct F_IPint_bits F_IPint_bits;
+struct F_IPint_bits
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_bytestoip(void*);
+typedef struct F_IPint_bytestoip F_IPint_bytestoip;
+struct F_IPint_bytestoip
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	Array*	buf;
+};
+void IPint_cmp(void*);
+typedef struct F_IPint_cmp F_IPint_cmp;
+struct F_IPint_cmp
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_copy(void*);
+typedef struct F_IPint_copy F_IPint_copy;
+struct F_IPint_copy
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_div(void*);
+typedef struct F_IPint_div F_IPint_div;
+struct F_IPint_div
+{
+	WORD	regs[NREG-1];
+	struct{ IPints_IPint* t0; IPints_IPint* t1; }*	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_eq(void*);
+typedef struct F_IPint_eq F_IPint_eq;
+struct F_IPint_eq
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_expmod(void*);
+typedef struct F_IPint_expmod F_IPint_expmod;
+struct F_IPint_expmod
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	base;
+	IPints_IPint*	exp;
+	IPints_IPint*	mod;
+};
+void IPints_genprime(void*);
+typedef struct F_IPints_genprime F_IPints_genprime;
+struct F_IPints_genprime
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	WORD	nbits;
+	WORD	nrep;
+};
+void IPints_gensafeprime(void*);
+typedef struct F_IPints_gensafeprime F_IPints_gensafeprime;
+struct F_IPints_gensafeprime
+{
+	WORD	regs[NREG-1];
+	struct{ IPints_IPint* t0; IPints_IPint* t1; }*	ret;
+	uchar	temps[12];
+	WORD	nbits;
+	WORD	nrep;
+};
+void IPints_genstrongprime(void*);
+typedef struct F_IPints_genstrongprime F_IPints_genstrongprime;
+struct F_IPints_genstrongprime
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	WORD	nbits;
+	WORD	nrep;
+};
+void IPint_inttoip(void*);
+typedef struct F_IPint_inttoip F_IPint_inttoip;
+struct F_IPint_inttoip
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	WORD	i;
+};
+void IPint_invert(void*);
+typedef struct F_IPint_invert F_IPint_invert;
+struct F_IPint_invert
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	base;
+	IPints_IPint*	mod;
+};
+void IPint_iptob64(void*);
+typedef struct F_IPint_iptob64 F_IPint_iptob64;
+struct F_IPint_iptob64
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_iptob64z(void*);
+typedef struct F_IPint_iptob64z F_IPint_iptob64z;
+struct F_IPint_iptob64z
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_iptobebytes(void*);
+typedef struct F_IPint_iptobebytes F_IPint_iptobebytes;
+struct F_IPint_iptobebytes
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_iptobytes(void*);
+typedef struct F_IPint_iptobytes F_IPint_iptobytes;
+struct F_IPint_iptobytes
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_iptoint(void*);
+typedef struct F_IPint_iptoint F_IPint_iptoint;
+struct F_IPint_iptoint
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_iptostr(void*);
+typedef struct F_IPint_iptostr F_IPint_iptostr;
+struct F_IPint_iptostr
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+	WORD	base;
+};
+void IPint_mod(void*);
+typedef struct F_IPint_mod F_IPint_mod;
+struct F_IPint_mod
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_mul(void*);
+typedef struct F_IPint_mul F_IPint_mul;
+struct F_IPint_mul
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_neg(void*);
+typedef struct F_IPint_neg F_IPint_neg;
+struct F_IPint_neg
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+};
+void IPint_not(void*);
+typedef struct F_IPint_not F_IPint_not;
+struct F_IPint_not
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+};
+void IPint_ori(void*);
+typedef struct F_IPint_ori F_IPint_ori;
+struct F_IPint_ori
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPints_probably_prime(void*);
+typedef struct F_IPints_probably_prime F_IPints_probably_prime;
+struct F_IPints_probably_prime
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	IPints_IPint*	n;
+	WORD	nrep;
+};
+void IPint_random(void*);
+typedef struct F_IPint_random F_IPint_random;
+struct F_IPint_random
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	WORD	nbits;
+};
+void IPint_shl(void*);
+typedef struct F_IPint_shl F_IPint_shl;
+struct F_IPint_shl
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+	WORD	n;
+};
+void IPint_shr(void*);
+typedef struct F_IPint_shr F_IPint_shr;
+struct F_IPint_shr
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i;
+	WORD	n;
+};
+void IPint_strtoip(void*);
+typedef struct F_IPint_strtoip F_IPint_strtoip;
+struct F_IPint_strtoip
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	String*	str;
+	WORD	base;
+};
+void IPint_sub(void*);
+typedef struct F_IPint_sub F_IPint_sub;
+struct F_IPint_sub
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+void IPint_xor(void*);
+typedef struct F_IPint_xor F_IPint_xor;
+struct F_IPint_xor
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	IPints_IPint*	i1;
+	IPints_IPint*	i2;
+};
+#define IPints_PATH "$IPints"
+void Crypt_aescbc(void*);
+typedef struct F_Crypt_aescbc F_Crypt_aescbc;
+struct F_Crypt_aescbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_AESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_aessetup(void*);
+typedef struct F_Crypt_aessetup F_Crypt_aessetup;
+struct F_Crypt_aessetup
+{
+	WORD	regs[NREG-1];
+	Crypt_AESstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void Crypt_blowfishcbc(void*);
+typedef struct F_Crypt_blowfishcbc F_Crypt_blowfishcbc;
+struct F_Crypt_blowfishcbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_BFstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_blowfishsetup(void*);
+typedef struct F_Crypt_blowfishsetup F_Crypt_blowfishsetup;
+struct F_Crypt_blowfishsetup
+{
+	WORD	regs[NREG-1];
+	Crypt_BFstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void DigestState_copy(void*);
+typedef struct F_DigestState_copy F_DigestState_copy;
+struct F_DigestState_copy
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Crypt_DigestState*	d;
+};
+void Crypt_descbc(void*);
+typedef struct F_Crypt_descbc F_Crypt_descbc;
+struct F_Crypt_descbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_DESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_desecb(void*);
+typedef struct F_Crypt_desecb F_Crypt_desecb;
+struct F_Crypt_desecb
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_DESstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_dessetup(void*);
+typedef struct F_Crypt_dessetup F_Crypt_dessetup;
+struct F_Crypt_dessetup
+{
+	WORD	regs[NREG-1];
+	Crypt_DESstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void Crypt_dhparams(void*);
+typedef struct F_Crypt_dhparams F_Crypt_dhparams;
+struct F_Crypt_dhparams
+{
+	WORD	regs[NREG-1];
+	struct{ IPints_IPint* t0; IPints_IPint* t1; }*	ret;
+	uchar	temps[12];
+	WORD	nbits;
+};
+void Crypt_dsagen(void*);
+typedef struct F_Crypt_dsagen F_Crypt_dsagen;
+struct F_Crypt_dsagen
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	Crypt_PK*	oldpk;
+};
+void Crypt_eggen(void*);
+typedef struct F_Crypt_eggen F_Crypt_eggen;
+struct F_Crypt_eggen
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	nrep;
+};
+void Crypt_genSK(void*);
+typedef struct F_Crypt_genSK F_Crypt_genSK;
+struct F_Crypt_genSK
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	String*	algname;
+	WORD	length;
+};
+void Crypt_genSKfromPK(void*);
+typedef struct F_Crypt_genSKfromPK F_Crypt_genSKfromPK;
+struct F_Crypt_genSKfromPK
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	Crypt_PK*	pk;
+};
+void Crypt_hmac_md5(void*);
+typedef struct F_Crypt_hmac_md5 F_Crypt_hmac_md5;
+struct F_Crypt_hmac_md5
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	data;
+	WORD	n;
+	Array*	key;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_hmac_sha1(void*);
+typedef struct F_Crypt_hmac_sha1 F_Crypt_hmac_sha1;
+struct F_Crypt_hmac_sha1
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	data;
+	WORD	n;
+	Array*	key;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_ideacbc(void*);
+typedef struct F_Crypt_ideacbc F_Crypt_ideacbc;
+struct F_Crypt_ideacbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_IDEAstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_ideaecb(void*);
+typedef struct F_Crypt_ideaecb F_Crypt_ideaecb;
+struct F_Crypt_ideaecb
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_IDEAstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Crypt_ideasetup(void*);
+typedef struct F_Crypt_ideasetup F_Crypt_ideasetup;
+struct F_Crypt_ideasetup
+{
+	WORD	regs[NREG-1];
+	Crypt_IDEAstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
+void Crypt_md4(void*);
+typedef struct F_Crypt_md4 F_Crypt_md4;
+struct F_Crypt_md4
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_md5(void*);
+typedef struct F_Crypt_md5 F_Crypt_md5;
+struct F_Crypt_md5
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_rc4(void*);
+typedef struct F_Crypt_rc4 F_Crypt_rc4;
+struct F_Crypt_rc4
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_RC4state*	state;
+	Array*	buf;
+	WORD	n;
+};
+void Crypt_rc4back(void*);
+typedef struct F_Crypt_rc4back F_Crypt_rc4back;
+struct F_Crypt_rc4back
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_RC4state*	state;
+	WORD	n;
+};
+void Crypt_rc4setup(void*);
+typedef struct F_Crypt_rc4setup F_Crypt_rc4setup;
+struct F_Crypt_rc4setup
+{
+	WORD	regs[NREG-1];
+	Crypt_RC4state**	ret;
+	uchar	temps[12];
+	Array*	seed;
+};
+void Crypt_rc4skip(void*);
+typedef struct F_Crypt_rc4skip F_Crypt_rc4skip;
+struct F_Crypt_rc4skip
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Crypt_RC4state*	state;
+	WORD	n;
+};
+void Crypt_rsadecrypt(void*);
+typedef struct F_Crypt_rsadecrypt F_Crypt_rsadecrypt;
+struct F_Crypt_rsadecrypt
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	Crypt_SK*	k;
+	IPints_IPint*	m;
+};
+void Crypt_rsaencrypt(void*);
+typedef struct F_Crypt_rsaencrypt F_Crypt_rsaencrypt;
+struct F_Crypt_rsaencrypt
+{
+	WORD	regs[NREG-1];
+	IPints_IPint**	ret;
+	uchar	temps[12];
+	Crypt_PK*	k;
+	IPints_IPint*	m;
+};
+void Crypt_rsafill(void*);
+typedef struct F_Crypt_rsafill F_Crypt_rsafill;
+struct F_Crypt_rsafill
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	IPints_IPint*	n;
+	IPints_IPint*	ek;
+	IPints_IPint*	dk;
+	IPints_IPint*	p;
+	IPints_IPint*	q;
+};
+void Crypt_rsagen(void*);
+typedef struct F_Crypt_rsagen F_Crypt_rsagen;
+struct F_Crypt_rsagen
+{
+	WORD	regs[NREG-1];
+	Crypt_SK**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	elen;
+	WORD	nrep;
+};
+void Crypt_sha1(void*);
+typedef struct F_Crypt_sha1 F_Crypt_sha1;
+struct F_Crypt_sha1
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_sha224(void*);
+typedef struct F_Crypt_sha224 F_Crypt_sha224;
+struct F_Crypt_sha224
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_sha256(void*);
+typedef struct F_Crypt_sha256 F_Crypt_sha256;
+struct F_Crypt_sha256
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_sha384(void*);
+typedef struct F_Crypt_sha384 F_Crypt_sha384;
+struct F_Crypt_sha384
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_sha512(void*);
+typedef struct F_Crypt_sha512 F_Crypt_sha512;
+struct F_Crypt_sha512
+{
+	WORD	regs[NREG-1];
+	Crypt_DigestState**	ret;
+	uchar	temps[12];
+	Array*	buf;
+	WORD	n;
+	Array*	digest;
+	Crypt_DigestState*	state;
+};
+void Crypt_sign(void*);
+typedef struct F_Crypt_sign F_Crypt_sign;
+struct F_Crypt_sign
+{
+	WORD	regs[NREG-1];
+	Crypt_PKsig**	ret;
+	uchar	temps[12];
+	Crypt_SK*	sk;
+	IPints_IPint*	m;
+};
+void Crypt_sktopk(void*);
+typedef struct F_Crypt_sktopk F_Crypt_sktopk;
+struct F_Crypt_sktopk
+{
+	WORD	regs[NREG-1];
+	Crypt_PK**	ret;
+	uchar	temps[12];
+	Crypt_SK*	sk;
+};
+void Crypt_verify(void*);
+typedef struct F_Crypt_verify F_Crypt_verify;
+struct F_Crypt_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Crypt_PK*	pk;
+	Crypt_PKsig*	sig;
+	IPints_IPint*	m;
+};
+#define Crypt_PATH "$Crypt"
+#define Crypt_SHA1dlen 20
+#define Crypt_SHA224dlen 28
+#define Crypt_SHA256dlen 32
+#define Crypt_SHA384dlen 48
+#define Crypt_SHA512dlen 64
+#define Crypt_MD5dlen 16
+#define Crypt_MD4dlen 16
+#define Crypt_Encrypt 0
+#define Crypt_Decrypt 1
+#define Crypt_AESbsize 16
+#define Crypt_DESbsize 8
+#define Crypt_IDEAbsize 8
+#define Crypt_BFbsize 8
+void Loader_compile(void*);
+typedef struct F_Loader_compile F_Loader_compile;
+struct F_Loader_compile
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+	WORD	flag;
+};
+void Loader_dnew(void*);
+typedef struct F_Loader_dnew F_Loader_dnew;
+struct F_Loader_dnew
+{
+	WORD	regs[NREG-1];
+	Loader_Niladt**	ret;
+	uchar	temps[12];
+	WORD	size;
+	Array*	map;
+};
+void Loader_ext(void*);
+typedef struct F_Loader_ext F_Loader_ext;
+struct F_Loader_ext
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+	WORD	idx;
+	WORD	pc;
+	WORD	tdesc;
+};
+void Loader_ifetch(void*);
+typedef struct F_Loader_ifetch F_Loader_ifetch;
+struct F_Loader_ifetch
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+};
+void Loader_link(void*);
+typedef struct F_Loader_link F_Loader_link;
+struct F_Loader_link
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+};
+void Loader_newmod(void*);
+typedef struct F_Loader_newmod F_Loader_newmod;
+struct F_Loader_newmod
+{
+	WORD	regs[NREG-1];
+	Modlink**	ret;
+	uchar	temps[12];
+	String*	name;
+	WORD	ss;
+	WORD	nlink;
+	Array*	inst;
+	Loader_Niladt*	data;
+};
+void Loader_tdesc(void*);
+typedef struct F_Loader_tdesc F_Loader_tdesc;
+struct F_Loader_tdesc
+{
+	WORD	regs[NREG-1];
+	Array**	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+};
+void Loader_tnew(void*);
+typedef struct F_Loader_tnew F_Loader_tnew;
+struct F_Loader_tnew
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Modlink*	mp;
+	WORD	size;
+	Array*	map;
+};
+#define Loader_PATH "$Loader"
+void Face_haschar(void*);
+typedef struct F_Face_haschar F_Face_haschar;
+struct F_Face_haschar
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Freetype_Face*	face;
+	WORD	c;
+};
+void Face_loadglyph(void*);
+typedef struct F_Face_loadglyph F_Face_loadglyph;
+struct F_Face_loadglyph
+{
+	WORD	regs[NREG-1];
+	Freetype_Glyph**	ret;
+	uchar	temps[12];
+	Freetype_Face*	face;
+	WORD	c;
+};
+void Freetype_newface(void*);
+typedef struct F_Freetype_newface F_Freetype_newface;
+struct F_Freetype_newface
+{
+	WORD	regs[NREG-1];
+	Freetype_Face**	ret;
+	uchar	temps[12];
+	String*	path;
+	WORD	index;
+};
+void Freetype_newmemface(void*);
+typedef struct F_Freetype_newmemface F_Freetype_newmemface;
+struct F_Freetype_newmemface
+{
+	WORD	regs[NREG-1];
+	Freetype_Face**	ret;
+	uchar	temps[12];
+	Array*	data;
+	WORD	index;
+};
+void Face_setcharsize(void*);
+typedef struct F_Face_setcharsize F_Face_setcharsize;
+struct F_Face_setcharsize
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Freetype_Face*	face;
+	WORD	pts;
+	WORD	hdpi;
+	WORD	vdpi;
+};
+void Face_settransform(void*);
+typedef struct F_Face_settransform F_Face_settransform;
+struct F_Face_settransform
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Freetype_Face*	face;
+	Freetype_Matrix*	m;
+	Freetype_Vector*	v;
+};
+#define Freetype_PATH "$Freetype"
+#define Freetype_STYLE_ITALIC 1
+#define Freetype_STYLE_BOLD 2
--- /dev/null
+++ b/libinterp/sysmod.h
@@ -1,0 +1,48 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Sysmodtab[]={
+	"announce",0xb7c4ac0,Sys_announce,40,2,{0x0,0x80,},
+	"aprint",0x77442d46,Sys_aprint,0,0,{0},
+	"bind",0x66326d91,Sys_bind,48,2,{0x0,0xc0,},
+	"byte2char",0x3d6094f9,Sys_byte2char,40,2,{0x0,0x80,},
+	"char2byte",0x2ba5ab41,Sys_char2byte,48,2,{0x0,0x40,},
+	"chdir",0xc6935858,Sys_chdir,40,2,{0x0,0x80,},
+	"create",0x54db77d9,Sys_create,48,2,{0x0,0x80,},
+	"dial",0x29e90174,Sys_dial,40,2,{0x0,0xc0,},
+	"dirread",0x72210d71,Sys_dirread,40,2,{0x0,0x80,},
+	"dup",0x6584767b,Sys_dup,40,0,{0},
+	"export",0x6fc6dc03,Sys_export,48,2,{0x0,0xc0,},
+	"fauth",0x20ccc34b,Sys_fauth,40,2,{0x0,0xc0,},
+	"fd2path",0x749c6042,Sys_fd2path,40,2,{0x0,0x80,},
+	"fildes",0x1478f993,Sys_fildes,40,0,{0},
+	"file2chan",0x9f34d686,Sys_file2chan,40,2,{0x0,0xc0,},
+	"fprint",0xf46486c8,Sys_fprint,0,0,{0},
+	"fstat",0xda4499c2,Sys_fstat,40,2,{0x0,0x80,},
+	"fversion",0xfe9c0a06,Sys_fversion,48,2,{0x0,0xa0,},
+	"fwstat",0x50a6c7e0,Sys_fwstat,104,2,{0x0,0xbc,},
+	"iounit",0x5583b730,Sys_iounit,40,2,{0x0,0x80,},
+	"listen",0xb97416e0,Sys_listen,48,2,{0x0,0xe0,},
+	"millisec",0x616977e8,Sys_millisec,32,0,{0},
+	"mount",0x74c17b3a,Sys_mount,56,2,{0x0,0xe8,},
+	"open",0x8f477f99,Sys_open,40,2,{0x0,0x80,},
+	"pctl",0x5df27fb,Sys_pctl,40,2,{0x0,0x40,},
+	"pipe",0x1f2c52ea,Sys_pipe,40,2,{0x0,0x80,},
+	"pread",0x9d8aac6,Sys_pread,56,2,{0x0,0xc0,},
+	"print",0xac849033,Sys_print,0,0,{0},
+	"pwrite",0x9d8aac6,Sys_pwrite,56,2,{0x0,0xc0,},
+	"read",0x7cfef557,Sys_read,48,2,{0x0,0xc0,},
+	"readn",0x7cfef557,Sys_readn,48,2,{0x0,0xc0,},
+	"remove",0xc6935858,Sys_remove,40,2,{0x0,0x80,},
+	"seek",0xaeccaddb,Sys_seek,56,2,{0x0,0x80,},
+	"sleep",0xe67bf126,Sys_sleep,40,0,{0},
+	"sprint",0x4c0624b6,Sys_sprint,0,0,{0},
+	"stat",0x319328dd,Sys_stat,40,2,{0x0,0x80,},
+	"stream",0xb9e8f9ea,Sys_stream,48,2,{0x0,0xc0,},
+	"tokenize",0x57338f20,Sys_tokenize,40,2,{0x0,0xc0,},
+	"unmount",0x21e337e3,Sys_unmount,40,2,{0x0,0xc0,},
+	"utfbytes",0x1d4a1f4,Sys_utfbytes,40,2,{0x0,0x80,},
+	"werrstr",0xc6935858,Sys_werrstr,40,2,{0x0,0x80,},
+	"write",0x7cfef557,Sys_write,48,2,{0x0,0xc0,},
+	"wstat",0x56b02096,Sys_wstat,104,2,{0x0,0xbc,},
+	0
+};
+#define Sysmodlen	43
--- /dev/null
+++ b/libinterp/tkmod.h
@@ -1,0 +1,15 @@
+typedef struct{char *name; long sig; void (*fn)(void*); int size; int np; uchar map[16];} Runtab;
+Runtab Tkmodtab[]={
+	"cmd",0x1ee9697,Tk_cmd,40,2,{0x0,0xc0,},
+	"color",0xc6935858,Tk_color,40,2,{0x0,0x80,},
+	"getimage",0x80bea378,Tk_getimage,40,2,{0x0,0xc0,},
+	"keyboard",0x8671bae6,Tk_keyboard,40,2,{0x0,0x80,},
+	"namechan",0x35182638,Tk_namechan,48,2,{0x0,0xe0,},
+	"pointer",0x21188625,Tk_pointer,56,2,{0x0,0x80,},
+	"putimage",0x2dc55622,Tk_putimage,48,2,{0x0,0xf0,},
+	"quote",0xb2cd7190,Tk_quote,40,2,{0x0,0x80,},
+	"rect",0x683e6bae,Tk_rect,48,2,{0x0,0xc0,},
+	"toplevel",0x96ab1cc9,Tk_toplevel,40,2,{0x0,0xc0,},
+	0
+};
+#define Tkmodlen	10
binary files /dev/null b/libkern/abort.8 differ
binary files /dev/null b/libkern/abs.8 differ
binary files /dev/null b/libkern/atol.8 differ
binary files /dev/null b/libkern/charstod.8 differ
binary files /dev/null b/libkern/cistrcmp.8 differ
binary files /dev/null b/libkern/cistrncmp.8 differ
binary files /dev/null b/libkern/cistrstr.8 differ
binary files /dev/null b/libkern/cleanname.8 differ
binary files /dev/null b/libkern/convD2M.8 differ
binary files /dev/null b/libkern/convM2D.8 differ
binary files /dev/null b/libkern/convM2S.8 differ
binary files /dev/null b/libkern/convS2M.8 differ
binary files /dev/null b/libkern/dofmt.8 differ
binary files /dev/null b/libkern/exp.8 differ
binary files /dev/null b/libkern/fcallfmt.8 differ
binary files /dev/null b/libkern/floor.8 differ
binary files /dev/null b/libkern/fmt.8 differ
binary files /dev/null b/libkern/fmtprint.8 differ
binary files /dev/null b/libkern/fmtquote.8 differ
binary files /dev/null b/libkern/fmtstr.8 differ
binary files /dev/null b/libkern/fmtvprint.8 differ
binary files /dev/null b/libkern/frexp-386.8 differ
binary files /dev/null b/libkern/getfcr-386.8 differ
binary files /dev/null b/libkern/getfields.8 differ
binary files /dev/null b/libkern/log.8 differ
binary files /dev/null b/libkern/memccpy.8 differ
binary files /dev/null b/libkern/memchr.8 differ
binary files /dev/null b/libkern/memcmp.8 differ
binary files /dev/null b/libkern/memmove-386.8 differ
binary files /dev/null b/libkern/memset-386.8 differ
binary files /dev/null b/libkern/nan-386.8 differ
binary files /dev/null b/libkern/pow.8 differ
binary files /dev/null b/libkern/pow10.8 differ
binary files /dev/null b/libkern/qsort.8 differ
binary files /dev/null b/libkern/rune.8 differ
binary files /dev/null b/libkern/runestrlen.8 differ
binary files /dev/null b/libkern/seprint.8 differ
binary files /dev/null b/libkern/sin.8 differ
binary files /dev/null b/libkern/smprint.8 differ
binary files /dev/null b/libkern/snprint.8 differ
binary files /dev/null b/libkern/sqrt.8 differ
binary files /dev/null b/libkern/strcat.8 differ
binary files /dev/null b/libkern/strchr-386.8 differ
binary files /dev/null b/libkern/strcmp.8 differ
binary files /dev/null b/libkern/strcpy.8 differ
binary files /dev/null b/libkern/strdup.8 differ
binary files /dev/null b/libkern/strecpy.8 differ
binary files /dev/null b/libkern/strlen.8 differ
binary files /dev/null b/libkern/strncmp.8 differ
binary files /dev/null b/libkern/strncpy.8 differ
binary files /dev/null b/libkern/strrchr.8 differ
binary files /dev/null b/libkern/strstr.8 differ
binary files /dev/null b/libkern/strtod.8 differ
binary files /dev/null b/libkern/strtol.8 differ
binary files /dev/null b/libkern/strtoll.8 differ
binary files /dev/null b/libkern/strtoul.8 differ
binary files /dev/null b/libkern/strtoull.8 differ
binary files /dev/null b/libkern/tokenize.8 differ
binary files /dev/null b/libkern/toupper.8 differ
binary files /dev/null b/libkern/u16.8 differ
binary files /dev/null b/libkern/u32.8 differ
binary files /dev/null b/libkern/u64.8 differ
binary files /dev/null b/libkern/utfecpy.8 differ
binary files /dev/null b/libkern/utflen.8 differ
binary files /dev/null b/libkern/utfnlen.8 differ
binary files /dev/null b/libkern/utfrrune.8 differ
binary files /dev/null b/libkern/utfrune.8 differ
binary files /dev/null b/libkern/vlop-386.8 differ
binary files /dev/null b/libkern/vlrt-386.8 differ
binary files /dev/null b/libkern/vseprint.8 differ
binary files /dev/null b/libkern/vsmprint.8 differ
binary files /dev/null b/libkern/vsnprint.8 differ
--- /dev/null
+++ b/limbo/y.tab.c
@@ -1,0 +1,3052 @@
+
+#line	2	"limbo.y"
+#include "limbo.h"
+
+#line	5	"limbo.y"
+typedef union 
+{
+	struct{
+		Src	src;
+		union{
+			Sym	*idval;
+			Long	ival;
+			Real	rval;
+		}v;
+	}tok;
+	Decl	*ids;
+	Node	*node;
+	Type	*type;
+	Typelist *types;
+} YYSTYPE;
+extern	int	yyerrflag;
+#ifndef	YYMAXDEPTH
+#define	YYMAXDEPTH	150
+#endif
+YYSTYPE	yylval;
+YYSTYPE	yyval;
+#define	Landeq	57346
+#define	Loreq	57347
+#define	Lxoreq	57348
+#define	Llsheq	57349
+#define	Lrsheq	57350
+#define	Laddeq	57351
+#define	Lsubeq	57352
+#define	Lmuleq	57353
+#define	Ldiveq	57354
+#define	Lmodeq	57355
+#define	Lexpeq	57356
+#define	Ldeclas	57357
+#define	Lload	57358
+#define	Loror	57359
+#define	Landand	57360
+#define	Lcons	57361
+#define	Leq	57362
+#define	Lneq	57363
+#define	Lleq	57364
+#define	Lgeq	57365
+#define	Llsh	57366
+#define	Lrsh	57367
+#define	Lexp	57368
+#define	Lcomm	57369
+#define	Linc	57370
+#define	Ldec	57371
+#define	Lof	57372
+#define	Lref	57373
+#define	Lif	57374
+#define	Lelse	57375
+#define	Lfn	57376
+#define	Lexcept	57377
+#define	Lraises	57378
+#define	Lmdot	57379
+#define	Lto	57380
+#define	Lor	57381
+#define	Lrconst	57382
+#define	Lconst	57383
+#define	Lid	57384
+#define	Ltid	57385
+#define	Lsconst	57386
+#define	Llabs	57387
+#define	Lnil	57388
+#define	Llen	57389
+#define	Lhd	57390
+#define	Ltl	57391
+#define	Ltagof	57392
+#define	Limplement	57393
+#define	Limport	57394
+#define	Linclude	57395
+#define	Lcon	57396
+#define	Ltype	57397
+#define	Lmodule	57398
+#define	Lcyclic	57399
+#define	Ladt	57400
+#define	Larray	57401
+#define	Llist	57402
+#define	Lchan	57403
+#define	Lself	57404
+#define	Ldo	57405
+#define	Lwhile	57406
+#define	Lfor	57407
+#define	Lbreak	57408
+#define	Lalt	57409
+#define	Lcase	57410
+#define	Lpick	57411
+#define	Lcont	57412
+#define	Lreturn	57413
+#define	Lexit	57414
+#define	Lspawn	57415
+#define	Lraise	57416
+#define	Lfix	57417
+#define	Ldynamic	57418
+#define YYEOFCODE 1
+#define YYERRCODE 2
+
+#line	1596	"limbo.y"
+
+
+static	char	*mkfileext(char*, char*, char*);
+static	void	usage(void);
+
+static	int	dosym;
+static	int	toterrors;
+static	ulong	canonnanbits[] = { 0x7fffffff, 0xffffffff};
+static	char*	infile;
+
+#define SLASHMOD	"/module"
+
+static char*
+getroot(void)
+{
+	int n;
+	char *e, *l, *s;
+
+	if((e = getenv("EMU")) != nil){
+		for(s = e; *e != '\0'; e++){
+			if(*e == '-' && *(e+1) == 'r' && (e == s || *(e-1) == ' ' || *(e-1) == '\t')){
+				e += 2;
+				l = strchr(e, ' ');
+				if(l != nil)
+					*l = '\0';
+				if((n = strlen(e)) > 0){
+					s = malloc(n+1);
+					strcpy(s, e);
+					return s;
+				}
+			}
+		}
+	}
+	if((e = getenv("ROOT")) != nil)
+		return strdup(e);
+	return nil;
+}
+
+void
+main(int argc, char *argv[])
+{
+	char *s, *ofile, *ext, *root;
+	int i;
+
+	FPinit();
+	FPcontrol(0, INVAL|ZDIV|OVFL|UNFL|INEX);
+	canonnan = canontod(canonnanbits);
+
+	fmtinstall('D', dotconv);
+	fmtinstall('I', instconv);
+	fmtinstall('K', declconv);
+	fmtinstall('k', storeconv);
+	fmtinstall('L', lineconv);
+	fmtinstall('M', mapconv);
+	fmtinstall('n', nodeconv);		/* exp structure */
+	fmtinstall('O', opconv);
+	fmtinstall('g', gfltconv);
+	fmtinstall('Q', etconv);		/* src expression with type */
+	fmtinstall('R', ctypeconv);		/* c equivalent type */
+	fmtinstall('P', ctypeconv);		/* c equivalent type - pointer type */
+	fmtinstall('T', typeconv);		/* source style types */
+	fmtinstall('t', stypeconv);		/* structurally descriptive type */
+	fmtinstall('U', srcconv);
+	fmtinstall('v', expconv);		/* src expression */
+	fmtinstall('V', expconv);		/* src expression in '' */
+	lexinit();
+	typeinit();
+	optabinit();
+
+	gendis = 1;
+	asmsym = 0;
+	maxerr = 20;
+	ofile = nil;
+	ext = nil;
+	ARGBEGIN{
+	case 'D':
+		/*
+		 * debug flags:
+		 *
+		 * a	alt compilation
+		 * A	array constructor compilation
+		 * b	boolean and branch compilation
+		 * c	case compilation
+		 * d	function declaration
+		 * D	descriptor generation
+		 * e	expression compilation
+		 * E	addressable expression compilation
+		 * f	print arguments for compiled functions
+		 * F	constant folding
+		 * g	print out globals
+		 * m	module declaration and type checking
+		 * n	nil references
+		 * s	print sizes of output file sections
+		 * S	type signing
+		 * t	type checking function bodies
+		 * T	timing
+		 * v	global var and constant compilation
+		 * x	adt verification
+		 * Y	tuple compilation
+		 * z Z	bug fixes
+		 */
+		s = ARGF();
+		while(s && *s)
+			debug[*s++] = 1;
+		break;
+	case 'I':
+		s = ARGF();
+		if(s == nil)
+			usage();
+		addinclude(s);
+		break;
+	case 'G':
+		asmsym = 1;
+		break;
+	case 'S':
+		gendis = 0;
+		break;
+	case 'a':
+		emitstub = 1;
+		break;
+	case 'A':
+		emitstub = emitdyn = 1;
+		break;
+	case 'c':
+		mustcompile = 1;
+		break;
+	case 'C':
+		dontcompile = 1;
+		break;
+	case 'e':
+		maxerr = 1000;
+		break;
+	case 'f':
+		isfatal = 1;
+		break;
+	case 'F':
+		newfnptr = 1;
+		break;
+	case 'g':
+		dosym = 1;
+		break;
+	case 'i':
+		dontinline = 1;
+		break;
+	case 'o':
+		ofile = ARGF();
+		break;
+	case 'O':
+		optims = 1;
+		break;
+	case 's':
+		s = ARGF();
+		if(s != nil)
+			fixss = atoi(s);
+		break;
+	case 't':
+		emittab = ARGF();
+		if(emittab == nil)
+			usage();
+		break;
+	case 'T':
+		emitcode = ARGF();
+		if(emitcode == nil)
+			usage();
+		break;
+	case 'd':
+		emitcode = ARGF();
+		if(emitcode == nil)
+			usage();
+		emitdyn = 1;
+		break;
+	case 'w':
+		superwarn = dowarn;
+		dowarn = 1;
+		break;
+	case 'x':
+		ext = ARGF();
+		break;
+	case 'X':
+		signdump = ARGF();
+		break;
+	case 'y':
+		oldcycles = 1;
+		break;
+	case 'z':
+		arrayz = 1;
+		break;
+	default:
+		usage();
+		break;
+	}ARGEND
+
+	if((root = getroot()) != nil){
+		char *r;
+
+		r = malloc(strlen(root)+strlen(SLASHMOD)+1);
+		strcpy(r, root);
+		strcat(r, SLASHMOD);
+		addinclude(r);
+		free(root);
+	}
+	else
+		addinclude(INCPATH);
+
+	if(argc == 0){
+		usage();
+	}else if(ofile != nil){
+		if(argc != 1)
+			usage();
+		translate(argv[0], ofile, mkfileext(ofile, ".dis", ".sbl"));
+	}else{
+		if(ext == nil){
+			ext = ".s";
+			if(gendis)
+				ext = ".dis";
+		}
+		for(i = 0; i < argc; i++){
+			s = strrchr(argv[i], '/');
+			if(s == nil)
+				s = argv[i];
+			else
+				s++;
+			if(argc > 1)
+				print("%s:\n", argv[i]);
+			ofile = mkfileext(s, ".b", ext);
+			translate(argv[i], ofile, mkfileext(ofile, ext, ".sbl"));
+		}
+	}
+	if(toterrors)
+		exits("errors");
+	exits(0);
+}
+
+static void
+usage(void)
+{
+	fprint(2, "usage: limbo [-CGSacgwe] [-I incdir] [-o outfile] [-{T|t|d} module] [-D debug] file ...\n");
+	exits("usage");
+}
+
+static char*
+mkfileext(char *file, char *oldext, char *ext)
+{
+	char *ofile;
+	int n, n2;
+
+	n = strlen(file);
+	n2 = strlen(oldext);
+	if(n >= n2 && strcmp(&file[n-n2], oldext) == 0)
+		n -= n2;
+	ofile = malloc(n + strlen(ext) + 1);
+	memmove(ofile, file, n);
+	strcpy(ofile+n, ext);
+	return ofile;
+}
+
+void
+translate(char *in, char *out, char *dbg)
+{
+	Decl *entry;
+	int doemit;
+
+	infile = in;
+	outfile = out;
+	symfile = dbg;
+	errors = 0;
+	bins[0] = Bopen(in, OREAD);
+	if(bins[0] == nil){
+		fprint(2, "can't open %s: %r\n", in);
+		toterrors++;
+		return;
+	}
+	doemit = emitstub || emittab || emitcode;
+	if(!doemit){
+		bout = Bopen(out, OWRITE);
+		if(bout == nil){
+			fprint(2, "can't open %s: %r\n", out);
+			toterrors++;
+			Bterm(bins[0]);
+			return;
+		}
+		if(dosym){
+			bsym = Bopen(dbg, OWRITE);
+			if(bsym == nil)
+				fprint(2, "can't open %s: %r\n", dbg);
+		}
+	}
+
+	lexstart(in);
+
+	popscopes();
+	typestart();
+	declstart();
+
+	yyparse();
+
+	entry = typecheck(!doemit);
+
+	modcom(entry);
+
+	fns = nil;
+	nfns = 0;
+	descriptors = nil;
+
+	if(bout != nil)
+		Bterm(bout);
+	if(bsym != nil)
+		Bterm(bsym);
+	toterrors += errors;
+	if(errors && bout != nil)
+		remove(out);
+	if(errors && bsym != nil)
+		remove(dbg);
+}
+
+void
+trapFPE(unsigned exception[5], int value[2])
+{
+	/* can't happen; it's just here to keep FPinit happy. */
+	USED(exception);
+	USED(value);
+}
+
+static char *
+win2inf(char *s)
+{
+	int nt = 0;
+	char *t;
+
+	if(strlen(s) > 1 && s[1] == ':'){
+		s[1] = '/';
+		s++;
+		nt = 1;
+	}
+	for(t = s; *t != '\0'; t++){
+		if(*t == '\\')
+			*t = '/';
+		if(nt)
+			*t = tolower(*t);
+	}
+	return s;
+}
+
+static char *
+cleann(char *s)
+{
+	char *p, *r, *t;
+	char buf[256];
+
+	r = t = malloc(strlen(s)+1);
+	strcpy(t, s);
+	t = win2inf(t);
+	if(*t != '/'){
+		p = win2inf(getwd(buf, sizeof(buf)));
+		s = malloc(strlen(p)+strlen(t)+2);
+		strcpy(s, p);
+		strcat(s, "/");
+		strcat(s, t);
+	}
+	else{
+		s = malloc(strlen(t)+1);
+		strcpy(s, t);
+	}
+	free(r);
+	/* print("cleann: %s\n", p); */
+	return cleanname(s);
+}
+
+char *
+srcpath(char *name, int nlen)
+{
+	int l1, l2;
+	char *r, *srcp, *t;
+
+	srcp = cleann(infile);
+	r = getroot();
+	if(r == nil){
+		l1 = strlen(INCPATH);
+		r = malloc(l1+1);
+		strcpy(r, INCPATH);
+		if(l1 >= strlen(SLASHMOD) && strcmp(r+l1-strlen(SLASHMOD), SLASHMOD) == 0)
+			r[l1-strlen(SLASHMOD)] = '\0';
+	}
+	t = cleann(r);
+	free(r);
+	r = t;
+	/* srcp relative to r */
+	l1 = strlen(srcp);
+	l2 = strlen(r);
+	if(l1 >= l2 && strncmp(srcp, r, l2) == 0){
+		/* nothing to do */
+	}else
+		l2 = 0;
+	strncpy(name, srcp+l2, nlen);
+	name[nlen-1] = '\0';
+	free(r);
+	free(srcp);
+	/* print("srcpath: %s\n", name); */
+	return name;
+}
+short	yyexca[] =
+{-1, 1,
+	1, -1,
+	-2, 0,
+-1, 3,
+	1, 3,
+	-2, 0,
+-1, 17,
+	39, 88,
+	50, 62,
+	54, 88,
+	99, 62,
+	-2, 250,
+-1, 209,
+	59, 29,
+	71, 29,
+	-2, 0,
+-1, 228,
+	1, 2,
+	-2, 0,
+-1, 271,
+	50, 176,
+	-2, 255,
+-1, 305,
+	59, 41,
+	71, 41,
+	91, 41,
+	-2, 0,
+-1, 307,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 376,
+	50, 62,
+	99, 62,
+	-2, 250,
+-1, 377,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 383,
+	53, 71,
+	54, 71,
+	-2, 110,
+-1, 385,
+	53, 72,
+	54, 72,
+	-2, 112,
+-1, 417,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 424,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 439,
+	53, 71,
+	54, 71,
+	-2, 111,
+-1, 440,
+	53, 72,
+	54, 72,
+	-2, 113,
+-1, 448,
+	71, 277,
+	99, 277,
+	-2, 163,
+-1, 465,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 482,
+	50, 126,
+	99, 126,
+	-2, 239,
+-1, 487,
+	71, 274,
+	-2, 0,
+-1, 499,
+	59, 47,
+	71, 47,
+	-2, 0,
+-1, 504,
+	59, 41,
+	71, 41,
+	91, 41,
+	-2, 0,
+-1, 510,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 544,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 550,
+	71, 154,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 558,
+	56, 59,
+	62, 59,
+	-2, 62,
+-1, 564,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 569,
+	71, 157,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 573,
+	72, 176,
+	-2, 163,
+-1, 592,
+	71, 160,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 598,
+	71, 168,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 602,
+	72, 175,
+	85, 150,
+	86, 150,
+	87, 150,
+	89, 150,
+	90, 150,
+	91, 150,
+	-2, 0,
+-1, 605,
+	50, 62,
+	56, 171,
+	62, 171,
+	99, 62,
+	-2, 250,
+};
+#define	YYNPROD	282
+#define	YYPRIVATE 57344
+#define	YYLAST	2674
+short	yyact[] =
+{
+ 375, 587, 449, 360, 501, 380, 408, 307, 365, 311,
+ 355, 447, 428, 295, 445, 184, 268,  15,  83,   8,
+ 101,  49,  82,   4, 317,  12,  42,  23,  48,  77,
+  78,  79, 109,  35, 196,  51, 540, 487, 359,   6,
+ 482,   3,   6, 396, 455, 454, 361,  14, 346,  21,
+  14, 378, 349, 290, 419, 283, 117, 223, 327,  31,
+ 284, 224, 221,  46, 461, 111, 104,  11, 513, 595,
+  40, 208, 597, 185, 163, 164, 165, 166, 167, 168,
+ 169, 170, 171, 172, 173, 174, 175,  43, 116, 581,
+ 181, 182, 183,  71,  10, 284, 203,  10, 206, 284,
+  92, 345, 345, 418, 207, 345,  32, 113,  32, 543,
+ 118, 291, 291,  44, 284, 118, 424, 423, 422, 481,
+ 426, 425, 427, 229, 230, 231, 232, 233, 234, 235,
+ 236, 237, 238, 239, 240, 509, 242, 243, 244, 245,
+ 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+ 256, 257, 258, 259, 260, 261, 262, 263, 185,   6,
+ 200, 271, 228, 479, 478, 305,  22,  14,  22, 269,
+ 477, 210, 434, 265, 216, 192, 193, 277, 561,  22,
+ 406, 282, 306, 420, 192, 193, 226, 285, 405, 205,
+ 403, 350, 286,  93, 555, 267, 215,  47, 411,  26,
+ 411,  25,  24, 508, 309, 308, 300, 591, 568,  63,
+ 553, 549, 227,   5,  10, 416, 415, 414, 192, 193,
+  75,  74,  69,  68,  73, 532,  18,  54,  55,  62,
+  60,  61,  64, 521, 294, 486, 213, 531, 192, 193,
+ 464, 310, 323, 302,  65,  66,  67, 111, 320, 395,
+  19, 379,  23, 562, 315, 576,  86, 204, 296, 504,
+  76, 191, 494,  84, 313, 475,  89,   6, 463, 394,
+  17, 357, 192, 193,  18,  14,  91,  81, 192, 193,
+ 280, 185,  43, 217,   2, 337,  13, 444, 209, 113,
+  80, 526,  19,  96, 575, 181, 335, 491,  87,  88,
+  85, 333, 314, 600, 212, 192, 193,  19,  44, 610,
+ 192, 193,  45, 107,  76, 344,  18, 377,  19, 489,
+ 483, 354,  10, 353, 298, 608,  86, 114, 389, 190,
+  33, 115, 484,  84, 214, 387,  89, 385, 114, 398,
+ 535, 383, 115, 194, 388, 197,  91,  81, 321, 560,
+ 352, 279, 322, 202,  45, 399, 400,   5,  18, 600,
+ 381, 503, 536, 495, 218, 599, 496, 412,  87,  88,
+  85, 417, 432, 558, 489, 185, 539, 489, 500, 431,
+ 596, 433, 430, 593,  76, 489, 489, 437, 102,  86,
+ 435, 584, 570,  22,  19, 448,  84, 337, 182,  89,
+ 489,  72, 410, 440, 313, 489, 551, 439, 590,  91,
+  81, 490, 333, 476,  17, 429,  70, 288,  18,  75,
+  74,  45, 469,  73, 465,  18, 474, 438, 472, 496,
+  13,  87,  88,  85, 287, 503, 266, 156, 281, 119,
+ 589, 103,  86, 192, 193, 448,  39,  76,  90,  84,
+ 158,  90,  89, 506, 289, 483, 564, 292, 293, 485,
+ 493,  36,  91,  81, 514, 588, 462, 197, 185, 413,
+ 404, 473, 167, 280, 326, 222, 519, 105, 518, 511,
+ 512, 316, 319, 507,  87,  88,  85,  86, 448, 523,
+ 519, 525, 524,  34,  84, 397, 529,  89, 176, 522,
+  76,  90, 328,  90, 528, 533, 393,  91,  81, 180,
+ 541,  90, 332, 179, 542, 537, 519, 329, 548, 176,
+ 199, 552,  90, 177, 198, 550, 195, 402, 178,  87,
+  88,  85, 157, 442, 160, 330, 161, 162, 556, 559,
+ 437, 313, 441, 325, 225,  76, 159, 158, 566, 342,
+ 343, 573, 565, 571, 567, 569, 347, 473, 137, 138,
+ 139, 136, 134, 519, 341, 579,  41, 201, 580, 602,
+ 573, 582, 583, 544, 382, 324, 220, 386, 219, 545,
+ 557, 471, 470, 467, 410, 421, 592, 391, 392,  39,
+ 594, 473, 186, 573, 598, 601,  90, 136, 134, 520,
+ 603,  19, 607, 241, 401,  29, 609,  27, 356, 534,
+ 304, 473,  90, 364, 120,  90,  90,  30,  90,  28,
+   1, 460, 270, 272,  86,  90, 312, 182, 167, 538,
+ 578,  84, 577, 409,  89, 499, 498, 586, 585,  90,
+  90,  16, 407, 194,  91,  81, 303, 351,   9, 473,
+ 547, 546, 443, 517,  50, 516, 452, 211,   7, 446,
+ 334, 456, 264, 457, 297, 502,  87,  88,  85,  52,
+  53,  56,  96, 367, 108,  59,  72, 106, 468, 112,
+  57,  58,  76,  63, 143, 142, 140, 141, 137, 138,
+ 139, 136, 134,  90,  75,  74,  69, 273,  73, 110,
+  18,  54,  55,  62,  60,  61,  64,  20,  90,  37,
+  38,   0,   0,   0,  90,   0, 276, 492, 274, 275,
+  67, 497, 140, 141, 137, 138, 139, 136, 134,   0,
+   0,   0,   0,   0,  76,  90,   0,   0,   0,   0,
+   0,   0, 497,   0,   0,  90,  90,   0,   0,   0,
+   0,   0,   0,   0,   0, 530,   0,   0,  90,  90,
+   0,   0,  90, 122, 123, 124, 125, 126, 127, 128,
+ 129, 130, 131, 132, 133, 135,   0, 155, 154, 153,
+ 152, 151, 150, 148, 149, 144, 145, 146, 147, 143,
+ 142, 140, 141, 137, 138, 139, 136, 134,   0, 339,
+   0,  90,   0,   0,   0,   0,  86,   0,   0,   0,
+  90,   0,   0,  84,  90,   0,  89,   0,  98,  90,
+   0,  90,   0,   0,   0, 362,  91,  81,   0,   0,
+  90,   0,   0,   0,   0,   0,  90,   0,   0,   0,
+  50,  95,   0,  97,  94,  99,   0, 100,  87,  88,
+  85,   0,   0,   0,   0,  52,  53,  56, 338,   0,
+   0,  59, 374,   0,  76,   0,  57,  58,   0,  63,
+ 366,   0,   0,   0,   0,  90,   0,   0,   0,  90,
+  75,  74, 376,  68,  73,   0,  18,  54,  55,  62,
+  60,  61,  64, 363, 505, 362,   0,   0,  13,   0,
+  90,   0,   0,   0,  65,  66,  67,   0,   0,   0,
+  50, 368,   0,  90,   0, 369, 370, 373, 371, 372,
+  76,   0,   0,   0,   0,  52,  53,  56,   0,   0,
+   0,  59, 374,   0,   0,   0,  57,  58,   0,  63,
+ 366,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  75,  74, 376,  68,  73,   0,  18,  54,  55,  62,
+  60,  61,  64, 363, 466, 362,   0,   0,  13,   0,
+   0,   0,   0,   0,  65,  66,  67,   0,   0,   0,
+  50, 368,   0,   0,   0, 369, 370, 373, 371, 372,
+  76,   0,   0,   0,   0,  52,  53,  56,   0,   0,
+   0,  59, 374,   0,   0,   0,  57,  58,   0,  63,
+ 366,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  75,  74, 376,  68,  73,   0,  18,  54,  55,  62,
+  60,  61,  64, 363, 436, 362,   0,   0,  13,   0,
+   0,   0,   0,   0,  65,  66,  67,   0,   0,   0,
+  50, 368,   0,   0,   0, 369, 370, 373, 371, 372,
+  76,   0,   0,   0,   0,  52,  53,  56,   0,   0,
+   0,  59, 374,   0,   0,   0,  57,  58,   0,  63,
+ 366,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  75,  74, 376,  68,  73,   0,  18,  54,  55,  62,
+  60,  61,  64, 363, 358, 604,   0,   0,  13,   0,
+   0,   0,   0,   0,  65,  66,  67,   0,   0,   0,
+  50, 368,   0,   0,   0, 369, 370, 373, 371, 372,
+  76,   0,   0,   0,   0,  52,  53, 606,   0,   0,
+   0,  59, 374,   0,   0,   0,  57,  58,   0,  63,
+ 366,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  75,  74, 605,  68,  73,   0,  18,  54,  55,  62,
+  60,  61,  64, 363, 572,   0,   0,   0,  13,   0,
+   0,   0,   0,   0,  65,  66,  67,   0,   0,  50,
+   0, 368,   0,   0,   0, 369, 370, 373, 371, 372,
+  76,   0,   0,   0,  52,  53, 450,   0,   0,   0,
+  59, 374,   0,   0,   0,  57,  58,   0,  63, 366,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,  75,
+  74, 376,  68,  73,   0,  18,  54,  55,  62,  60,
+  61,  64, 363, 362,   0,   0,   0,  13,   0,   0,
+   0,   0,   0,  65,  66,  67,   0,   0,  50,   0,
+ 368,   0,   0,   0, 369, 370, 373, 371, 372,  76,
+   0,   0,   0,  52,  53,  56,   0,   0,   0,  59,
+ 374,   0,   0,   0,  57,  58,   0,  63, 366,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,  75,  74,
+ 376,  68,  73,   0,  18,  54,  55,  62,  60,  61,
+  64, 363, 451,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,  65,  66,  67,   0,   0,  50,   0, 368,
+   0,   0,   0, 369, 370, 373, 371, 372,  76,   0,
+   0,   0,  52,  53, 450,  86,   0,   0,  59,  72,
+   0,   0,  84,  57,  58,  89,  63,   0,   0,   0,
+   0,   0,   0,   0,   0,  91,  81,  75,  74,  69,
+  68,  73,   0,  18,  54,  55,  62,  60,  61,  64,
+   0,   0,   0,  50,   0,   0,   0,  87,  88,  85,
+ 318,  65,  66,  67,   0,   0,   0,   0,  52,  53,
+  56,   0,   0,  76,  59,  72,   0,  76, 278,  57,
+  58,   0,  63,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,  75,  74,  69,  68,  73,   0,  18,
+  54,  55,  62,  60,  61,  64,   0,   0,  50,   0,
+   0,   0,   0,   0,   0,   0,   0,  65,  66,  67,
+   0,   0,   0,  52,  53,  56,   0,   0,   0,  59,
+  72,   0,   0,  76,  57,  58,   0,  63,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,  75,  74,
+  69,  68,  73,   0,  18,  54,  55,  62,  60,  61,
+  64,   0,   0,   0,  52,  53,  56,   0,   0,   0,
+  59,  72,  65,  66,  67,  57,  58,   0,  63,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,  76,  75,
+  74,  69,  68,  73,   0,  18,  54,  55,  62,  60,
+  61,  64,   0,   0,   0,   0,   0,   0,   0,   0,
+  86,   0,   0,  65,  66,  67,   0,  84,   0,   0,
+  89,   0,  98,   0,   0,   0,   0,   0,   0,  76,
+  91,  81,   0,   0,   0,   0,   0,   0,   0,  86,
+   0,   0,   0,   0,   0,  95,  84,  97,  94,  89,
+   0,  98,  87,  88,  85,   0,   0,   0,   0,  91,
+  81,   0,   0,   0,   0,   0,   0,   0,  76,   0,
+   0,   0,   0,   0,   0,   0, 459, 458,   0,   0,
+ 100,  87,  88,  85, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135,  76, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 563, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134, 153, 152, 151, 150, 148, 149,
+ 144, 145, 146, 147, 143, 142, 140, 141, 137, 138,
+ 139, 136, 134,   0, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135, 554, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134, 151,
+ 150, 148, 149, 144, 145, 146, 147, 143, 142, 140,
+ 141, 137, 138, 139, 136, 134,   0,   0,   0, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 527, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134, 150, 148, 149, 144, 145, 146,
+ 147, 143, 142, 140, 141, 137, 138, 139, 136, 134,
+   0,   0,   0,   0, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135, 480, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134,   0,   0,   0,   0,   0, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 348, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134, 144, 145, 146, 147, 143, 142,
+ 140, 141, 137, 138, 139, 136, 134,   0,   0,   0,
+   0,   0,   0,   0, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135, 340, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 301, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135, 299, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 189, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135, 188, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 135, 187, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134,   0,  86,   0,   0,   0,  86,
+   0,   0,  84,  86,   0,  89,  84,   0,   0,  89,
+ 384,   0,   0,  89,   0,  91,  81,   0,   0,  91,
+ 390,   0,   0,  91,  81,   0,   0, 121,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,  87,  88,  85,
+   0,  87,  88,  85,   0,  87,  88,  85,   0,   0,
+   0,   0,   0,  76,   0,   0,   0,  76,   0,   0,
+   0,  76, 122, 123, 124, 125, 126, 127, 128, 129,
+ 130, 131, 132, 133, 135,   0, 155, 154, 153, 152,
+ 151, 150, 148, 149, 144, 145, 146, 147, 143, 142,
+ 140, 141, 137, 138, 139, 136, 134,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, 132, 133, 135, 574, 155,
+ 154, 153, 152, 151, 150, 148, 149, 144, 145, 146,
+ 147, 143, 142, 140, 141, 137, 138, 139, 136, 134,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+ 135, 515, 155, 154, 153, 152, 151, 150, 148, 149,
+ 144, 145, 146, 147, 143, 142, 140, 141, 137, 138,
+ 139, 136, 134,   0,   0,   0, 122, 123, 124, 125,
+ 126, 127, 128, 129, 130, 131, 132, 133, 135, 488,
+ 155, 154, 153, 152, 151, 150, 148, 149, 144, 145,
+ 146, 147, 143, 142, 140, 141, 137, 138, 139, 136,
+ 134,   0,   0,   0, 336, 122, 123, 124, 125, 126,
+ 127, 128, 129, 130, 131, 132, 133, 135,   0, 155,
+ 154, 153, 152, 151, 150, 148, 149, 144, 145, 146,
+ 147, 143, 142, 140, 141, 137, 138, 139, 136, 134,
+   0,   0,   0, 331, 122, 123, 124, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 135,   0, 155, 154,
+ 153, 152, 151, 150, 148, 149, 144, 145, 146, 147,
+ 143, 142, 140, 141, 137, 138, 139, 136, 134,   0,
+ 510, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+ 131, 132, 133, 135,   0, 155, 154, 153, 152, 151,
+ 150, 148, 149, 144, 145, 146, 147, 143, 142, 140,
+ 141, 137, 138, 139, 136, 134,   0, 453, 122, 123,
+ 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+ 135,   0, 155, 154, 153, 152, 151, 150, 148, 149,
+ 144, 145, 146, 147, 143, 142, 140, 141, 137, 138,
+ 139, 136, 134, 155, 154, 153, 152, 151, 150, 148,
+ 149, 144, 145, 146, 147, 143, 142, 140, 141, 137,
+ 138, 139, 136, 134
+};
+short	yypact[] =
+{
+ 211,-1000, 334, 355,-1000, 130,-1000,-1000, 129, 127,
+ 603, 601,   9, 269, 443,-1000, 407, 525,-1000, 253,
+ -36, 125,-1000,-1000,-1000,-1000,-1000,1421,1421,1421,
+1421,2216, 562, 121, 767, 336, 382, -21, 427, 279,
+-1000, 334,  16,-1000,-1000,-1000, 380,-1000,2215,-1000,
+ 378, 493,1462,1462,1462,1462,1462,1462,1462,1462,
+1462,1462,1462,1462,1462, 478, 483, 468,1462, 163,
+1462,-1000,1421,-1000,-1000,-1000, 553,2160,2105,2050,
+ 257,-1000,-1000,-1000,2216, 481,2216, 479, 475, 525,
+-1000, 526,-1000,-1000,2216,1421, 185,1421,  32, 218,
+ 525, 234, 295, 525, 213,2216, 538, 536, -37,-1000,
+ 425,   7, -38,-1000,-1000,-1000, 502,-1000, 253,-1000,
+ 355,-1000,1421,1421,1421,1421,1421,1421,1421,1421,
+1421,1421,1421,1421, 599,1421,1421,1421,1421,1421,
+1421,1421,1421,1421,1421,1421,1421,1421,1421,1421,
+1421,1421,1421,1421,1421,1421,1421,1421, 377, 362,
+ 637,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
+-1000,-1000,-1000,-1000,-1000,-1000,1366, 291, 210,2216,
+1421,-1000,-1000,-1000,  15,2614,1421,-1000,-1000,-1000,
+-1000,1421, 375, 358, 390,2216,  13, 390,2216,2216,
+ 550, 585, 252,1995,-1000,1421,1940,-1000,2216, 608,
+  95,-1000,-1000, 134, 253,-1000,-1000, 334, 390,-1000,
+-1000, 268,1306,1306, 289,-1000,-1000,-1000, 355,2614,
+2614,2614,2614,2614,2614,2614,2614,2614,2614,2614,
+2614,1421,2614, 560, 560, 560, 560, 524, 524, 690,
+ 690, 654, 654, 654, 654,1898,1898,1845,1791,1737,
+1684,1684,1630,2635, 535, -39,-1000, 396, 501, 424,
+ -41,2614,-1000,1462, 457, 472,2216,2501, 467,1462,
+1421, 390,2462,-1000,1421, 759,1885, 523, 508, 390,
+-1000,2216, 390, 390, 336,   6, 390,2216,-1000,-1000,
+1830,-1000,  12, 120,-1000, 606, 201,1033,-1000,-1000,
+  11, 180,-1000, 298, 534,-1000, 390,-1000,2224, 390,
+-1000,-1000,-1000,2614,-1000,-1000,1421, 637,2220, 403,
+ 390, 461, 199,-1000, 178, -56, 450,2614,1421,-1000,
+-1000, 585, 585, 390,-1000, 448,-1000, 390,-1000, 118,
+-1000,-1000, 420, 116,-1000, 109,-1000, 334,-1000,-1000,
+-1000, 419, 145,-1000,   4, 111, 546,  31, 356, 356,
+1421,1421,1421, 100,1421,2614, 163, 963,-1000,-1000,
+ 334,-1000,-1000,-1000,2216,-1000, 390, 500, 491,2614,
+1462, 390, 390, 217,1310,-1000,1421,2216,2577,   3,
+   2, 390,2216,-1000,1530,-1000, -23,-1000,-1000,-1000,
+ 416, 198, 169,1501,-1000,-1000,-1000, 893, 544,2216,
+-1000,1421, 543, 542,1241,1421, 195, 354,  98,-1000,
+  92,  91,1775,  47,-1000,   0,-1000,-1000, 270,-1000,
+-1000,-1000,-1000, 390,1310, 164, -62,-1000,2424, 349,
+1462,-1000, 390,-1000,-1000,-1000, 390, 225,2216,1421,
+-1000, 192, 287, 376, 189, 823, 402,1421, 131,2540,
+1421,1421, -18, 414,2371,1310, 583,-1000,-1000,-1000,
+-1000,-1000,-1000, 350,-1000, 162,-1000,1310,1421,1310,
+1421,-1000, 219,1720, 334,1421,2216, 165, 154, 607,
+-1000, 278, 306,-1000, 606,-1000, 317,  -4,-1000,1421,
+1241,  37, 533, 540,-1000,1310, 140,-1000, 344,2424,
+1421,-1000,-1000,2614,-1000,2614,-1000,-1000, 139,1665,
+ 122,-1000,-1000, 314, 302,-1000, 290, 107, 183,-1000,
+-1000,1610, 408,1421,1241,1421, 137,-1000, 330,-1000,
+1172,-1000,2318,-1000,-1000,-1000, 232, 405,-1000, 193,
+-1000,-1000,1310,-1000,1241,  17,-1000, 531,-1000,1172,
+-1000, 329, 145,2424, 406,-1000,-1000, 136,-1000, 321,
+-1000,1421,  -3, 318,-1000,   1,-1000, 303,-1000,-1000,
+-1000,-1000,1172,-1000, 529,-1000,-1000,-1000,1103,-1000,
+ 406, 263,1241, 247, 145, 163,1462,-1000,-1000,-1000,
+-1000
+};
+short	yypgo[] =
+{
+   0, 258, 710, 709,  33,  24, 416,  22,  18,  46,
+ 707, 699, 679,  34, 677, 674,  32, 673,  12,   4,
+ 665,  70,   8,   0,  21,  35,  15, 662, 660,  93,
+  25,  67,  26,  14, 659,  11,   2,  38,  41,  23,
+ 658, 657,   3,   7, 655, 653, 651, 650, 648,  19,
+ 647, 646, 642,  10, 641, 638, 637,   1, 636, 635,
+ 633,   6,   5, 632, 630, 629,  17,  20, 626,   9,
+ 623,  16, 622, 621,  13, 620, 614, 613
+};
+short	yyr1[] =
+{
+   0,  76,  75,  75,  38,  38,  39,  39,  39,  39,
+  39,  39,  39,  39,  39,  39,  39,  30,  30,  37,
+  37,  37,  37,  37,  37,  37,  66,  66,  48,  51,
+  51,  51,  50,  50,  50,  50,  50,  49,  49,  73,
+  73,  53,  53,  53,  52,  52,  52,  62,  62,  61,
+  61,  60,  58,  58,  58,  59,  59,  59,  19,  20,
+  20,   9,  10,  10,   6,   6,  74,  74,  74,  74,
+   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
+   1,   1,   7,   7,   8,   8,  13,  13,  21,  21,
+   2,   2,   2,   3,   3,   4,   4,  14,  14,  15,
+  15,  16,  16,  16,  16,  11,  12,  12,  12,  12,
+   5,   5,   5,   5,  40,  67,  67,  67,  41,  41,
+  41,  54,  54,  43,  43,  43,  77,  77,  42,  42,
+  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,
+  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,
+  17,  17,  18,  18,  44,  45,  45,  46,  47,  47,
+  63,  64,  64,  36,  36,  36,  36,  36,  55,  56,
+  56,  57,  57,  57,  57,  22,  22,  23,  23,  23,
+  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,
+  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,
+  23,  23,  23,  23,  23,  23,  23,  23,  23,  23,
+  23,  23,  23,  24,  24,  24,  24,  24,  24,  24,
+  24,  24,  24,  24,  24,  24,  24,  24,  24,  24,
+  24,  24,  24,  24,  24,  24,  24,  25,  25,  25,
+  25,  25,  25,  25,  25,  25,  25,  25,  25,  25,
+  29,  29,  31,  72,  72,  71,  71,  70,  70,  70,
+  70,  65,  65,  32,  32,  32,  32,  27,  27,  28,
+  28,  26,  26,  33,  33,  34,  34,  35,  35,  69,
+  68,  68
+};
+short	yyr2[] =
+{
+   0,   0,   5,   1,   1,   2,   2,   1,   1,   2,
+   2,   4,   4,   4,   4,   4,   6,   1,   3,   3,
+   5,   5,   4,   6,   5,   1,   4,   7,   6,   0,
+   2,   1,   4,   2,   5,   5,   1,   8,  11,   0,
+   4,   0,   2,   1,   1,   1,   5,   0,   2,   5,
+   4,   4,   2,   2,   1,   2,   4,   4,   1,   1,
+   3,   1,   1,   3,   6,   4,   1,   2,   3,   4,
+   1,   1,   1,   3,   6,   2,   3,   3,   3,   3,
+   4,   1,   1,   4,   3,   6,   1,   3,   0,   3,
+   3,   3,   5,   1,   3,   1,   5,   0,   1,   1,
+   3,   3,   3,   3,   3,   1,   1,   1,   3,   3,
+   2,   3,   2,   3,   4,   4,   2,   0,   3,   2,
+   4,   2,   4,   0,   2,   2,   3,   5,   2,   2,
+   4,   3,   4,   6,   2,   5,   7,  10,   6,   8,
+   3,   3,   3,   3,   3,   6,   5,   8,   2,   8,
+   0,   2,   0,   1,   2,   2,   4,   2,   2,   4,
+   2,   2,   4,   1,   3,   1,   3,   1,   2,   2,
+   4,   1,   1,   3,   1,   0,   1,   1,   3,   3,
+   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
+   4,   3,   3,   3,   3,   3,   3,   3,   3,   3,
+   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
+   3,   3,   3,   1,   2,   2,   2,   2,   2,   2,
+   2,   2,   2,   2,   2,   2,   2,   6,   8,   7,
+   5,   3,   6,   4,   2,   2,   2,   1,   4,   3,
+   3,   3,   4,   6,   2,   2,   1,   1,   1,   6,
+   1,   1,   3,   1,   3,   1,   1,   1,   3,   3,
+   2,   1,   0,   1,   1,   3,   3,   0,   1,   1,
+   2,   1,   3,   1,   2,   1,   3,   1,   3,   2,
+   2,   4
+};
+short	yychk[] =
+{
+-1000, -75,  73, -38, -39,   2, -37, -40, -49, -48,
+ -29, -31, -30,  75,  -9, -66, -54,  59,  63,  39,
+ -10,  -9,  59, -39,  72,  72,  72,   4,  16,   4,
+  16,  50,  99,  61,  50,  -4,  54,  -3,  -2,  39,
+ -21,  41, -32, -31, -29,  59,  99,  72, -23, -24,
+  17, -25,  32,  33,  64,  65,  34,  43,  44,  38,
+  67,  68,  66,  46,  69,  81,  82,  83,  60,  59,
+  -6, -29,  39,  61,  58,  57,  97, -23, -23, -23,
+  -1,  60,  -7,  -8,  46,  83,  39,  81,  82,  49,
+  -6,  59, -31,  72,  77,  74,  -1,  76,  51,  78,
+  80, -67,  52,  59,  87,  50, -14,  34, -15, -16,
+ -11, -30, -12, -31,  59,  63,  -9,  40,  99,  59,
+ -76,  72,   4,   5,   6,   7,   8,   9,  10,  11,
+  12,  13,  14,  15,  38,  16,  37,  34,  35,  36,
+  32,  33,  31,  30,  26,  27,  28,  29,  24,  25,
+  23,  22,  21,  20,  19,  18,  59,  39,  54,  53,
+  41,  43,  44, -24, -24, -24, -24, -24, -24, -24,
+ -24, -24, -24, -24, -24, -24,  41,  45,  45,  45,
+  41, -24, -24, -24, -26, -23,  39,  72,  72,  72,
+  72,   4,  53,  54,  -1,  45, -13,  -1,  45,  45,
+ -21,  41,  -1, -23,  72,   4, -23,  72,  39,  70,
+ -21, -41,  70,   2,  39, -29, -21,  70,  -1,  40,
+  40,  99,  50,  50,  99,  42, -31, -29, -38, -23,
+ -23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
+ -23,   4, -23, -23, -23, -23, -23, -23, -23, -23,
+ -23, -23, -23, -23, -23, -23, -23, -23, -23, -23,
+ -23, -23, -23, -23, -27, -26,  59, -25, -71, -22,
+ -72, -23, -70,  60,  81,  82,  79, -23,  42,  60,
+  70,  -1, -23,  40,  99, -23, -23,  59,  59,  -1,
+  40,  99,  -1,  -1,  -4, -74,  -1,  79,  72,  72,
+ -23,  72, -13, -51,   2,  70,  87, -43,  71,  70,
+ -32, -69, -68,  -9,  34, -16,  -1,  -5,  84,  -1,
+  -5,  59,  63, -23,  40,  42,  50,  99,  45,  45,
+  -1,  42,  45, -24, -28, -26,  42, -23,  99,  40,
+  72,  41,  41,  -1, -67,  99,  42,  -1,  72,  40,
+  71, -50,  -9, -49, -66, -53,   2,  70,  71, -37,
+ -42,  -9,   2,  70, -77, -22,  47, -17,  88,  92,
+  93,  95,  96,  94,  39, -23,  59, -43,  40,  71,
+ -62,  62,  40,  -7,  46,  -8,  -1, -22, -71, -23,
+  60,  -1,  -1,  45,  70,  71,  99,  45, -23, -74,
+ -74,  -1,  79,  72,  50,  72,  71, -52, -61, -60,
+  -9,  91, -69,  50,  72,  71,  70, -43,  99,  50,
+  72,  39,  87,  86,  85,  90,  89,  91, -18,  59,
+ -18, -22, -23, -22,  72, -26,  71, -61,  -9,  -7,
+  -8,  42,  42,  -1,  70, -33, -34, -35, -23, -36,
+  34,   2,  -1,  40,  42,  42,  -1,  -1,  77,  76,
+ -73,  87,  50,  70,  71, -43,  71,  39,  -1, -23,
+  39,  39, -42,  -9, -23,  70,  59,  72,  72,  72,
+  72,  72,  40,  50,  62, -33,  71,  99,  55,  56,
+  62,  72,  -1, -23,  70,  76,  79,  -1, -58, -59,
+   2, -19, -20,  59,  70,  71,  51, -26,  72,   4,
+  40, -22, -22,  86,  50,  70, -44, -45, -36, -23,
+  16,  71, -35, -23, -36, -23,  72,  72, -69, -23,
+  -1,  72,  71, -62,   2,  62,  56, -53, -65,  59,
+  40, -23, -42,  72,  40,  39, -46, -47, -36,  71,
+ -43,  62, -23,  71,  72,  72, -19,  -9,  59, -19,
+  59,  71,  70,  72,  48, -22, -42, -22,  71, -43,
+  62, -36,   2, -23,  70,  62,  62, -63, -64, -36,
+ -42,  72,  40, -36,  62, -55, -56, -57,  59,  34,
+   2,  71, -43,  62, -22,  72,  62,  71, -43,  62,
+  56, -36,  40, -57,   2,  59,  34, -57,  62, -42,
+  62
+};
+short	yydef[] =
+{
+   0,  -2,   0,  -2,   4,   0,   7,   8,   0,   0,
+   0,  17,   0,   0,   0,  25,   0,  -2, 251,   0,
+  61,   0,  62,   5,   6,   9,  10,   0,   0,   0,
+   0,   0,   0,   0,   0, 117,   0,  95,  93,  97,
+ 121,   0,   0, 263, 264, 250,   0,   1,   0, 177,
+   0, 213,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0, 250,
+   0, 237,   0, 246, 247, 248,   0,   0,   0,   0,
+   0,  70,  71,  72,   0,   0,   0,   0,   0,  88,
+  81,  82,  18,  19,   0,   0,   0,   0,   0,   0,
+  88,   0,   0,  88,   0,   0,   0,   0,  98,  99,
+   0,   0, 105,  17, 106, 107,   0, 252,   0,  63,
+   0,  11,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0, 267,   0,   0,
+ 175, 244, 245, 214, 215, 216, 217, 218, 219, 220,
+ 221, 222, 223, 224, 225, 226,   0,   0,   0,   0,
+   0, 234, 235, 236,   0, 271,   0,  13,  12,  14,
+  15,   0,   0,   0,  75,   0,   0,  86,   0,   0,
+   0,   0,   0,   0,  22,   0,   0,  26,   0,  -2,
+   0, 114, 123,   0,   0, 116, 122,   0,  94,  90,
+  91,   0,   0,   0,   0,  89, 265, 266,  -2, 178,
+ 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
+ 189,   0, 191, 193, 194, 195, 196, 197, 198, 199,
+ 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
+ 210, 211, 212, 192,   0, 268, 240, 241, 253,   0,
+   0,  -2, 256, 257,   0,   0,   0,   0,   0,   0,
+   0, 231,   0, 239,   0,   0,   0,  73,  84,  76,
+  77,   0,  78,  79, 117,   0,  66,   0,  20,  21,
+   0,  24,   0,   0,  31,  -2,   0,  -2, 119, 123,
+   0,   0,  47,   0,   0, 100, 101, 102,   0, 103,
+ 104, 108, 109, 190, 238, 242, 175,   0,   0,   0,
+ 260,   0,   0, 233,   0, 269,   0, 272,   0,  65,
+  16,   0,   0,  87,  80,   0,  83,  67,  23,   0,
+  28,  30,   0,   0,  36,   0,  43,   0, 118, 124,
+ 125,   0,   0, 123,   0,   0,   0,   0, 152, 152,
+ 175,   0, 175,   0,   0, 176,  -2,  -2, 115,  96,
+ 279, 280,  92,  -2,   0,  -2,   0,   0, 254, 255,
+  70, 258, 259,   0,   0, 230, 270,   0,   0,   0,
+   0,  68,   0,  27,   0,  33,  39,  42,  44,  45,
+   0,   0,   0, 151, 128, 129, 123,  -2,   0,   0,
+ 134,   0,   0,   0,  -2,   0,   0,   0,   0, 153,
+   0,   0,   0,   0, 148,   0, 120,  48,   0,  -2,
+  -2, 243, 249, 227,   0,   0, 273, 275,  -2,   0,
+ 165, 167, 232,  64,  74,  85,  69,   0,   0,   0,
+  37,   0,   0,   0,   0,  -2, 131,   0,   0,   0,
+ 175, 175,   0,   0,   0,   0,   0, 140, 141, 142,
+ 143, 144,  -2,   0, 281,   0, 229,  -2,   0,   0,
+   0,  32,   0,   0,   0,   0,   0,   0,   0,  -2,
+  54,   0,  58,  59,  -2, 130, 262,   0, 132,   0,
+  -2,   0,   0,   0, 151,   0,   0, 123,   0, 163,
+   0, 228, 276, 164, 166, 278,  34,  35,   0,   0,
+   0,  50,  51,  52,  53,  55,   0,   0,   0, 261,
+ 127,   0, 135, 175,  -2, 175,   0, 123,   0, 146,
+  -2, 155,   0,  40,  46,  49,   0,   0,  -2,   0,
+  60,  38,   0, 133,  -2,   0, 138,   0, 145,  -2,
+ 158,   0, 167,  -2,   0,  56,  57,   0, 123,   0,
+ 136, 175,   0,   0, 156,   0, 123,   0, 171, 172,
+ 174, 149,  -2, 161,   0, 139, 159, 147,  -2, 169,
+   0,   0,  -2,   0, 174,  -2, 172, 173, 162, 137,
+ 170
+};
+short	yytok1[] =
+{
+   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,  64,   0,   0,   0,  36,  23,   0,
+  39,  40,  34,  32,  99,  33,  54,  35,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,  50,  72,
+  26,   4,  27,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,  41,   0,  42,  22,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,  70,  21,  71,  65
+};
+short	yytok2[] =
+{
+   2,   3,   5,   6,   7,   8,   9,  10,  11,  12,
+  13,  14,  15,  16,  17,  18,  19,  20,  24,  25,
+  28,  29,  30,  31,  37,  38,  43,  44,  45,  46,
+  47,  48,  49,  51,  52,  53,  55,  56,  57,  58,
+  59,  60,  61,  62,  63,  66,  67,  68,  69,  73,
+  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
+  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,
+  94,  95,  96,  97,  98
+};
+long	yytok3[] =
+{
+   0
+};
+#define YYFLAG 		-1000
+#define	yyclearin	yychar = -1
+#define	yyerrok		yyerrflag = 0
+
+#ifdef	yydebug
+#include	"y.debug"
+#else
+#define	yydebug		0
+char*	yytoknames[1];		/* for debugging */
+char*	yystates[1];		/* for debugging */
+#endif
+
+/*	parser for yacc output	*/
+
+int	yynerrs = 0;		/* number of errors */
+int	yyerrflag = 0;		/* error recovery flag */
+
+extern	int	fprint(int, char*, ...);
+extern	int	sprint(char*, char*, ...);
+
+char*
+yytokname(int yyc)
+{
+	static char x[16];
+
+	if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))
+	if(yytoknames[yyc-1])
+		return yytoknames[yyc-1];
+	sprint(x, "<%d>", yyc);
+	return x;
+}
+
+char*
+yystatname(int yys)
+{
+	static char x[16];
+
+	if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))
+	if(yystates[yys])
+		return yystates[yys];
+	sprint(x, "<%d>\n", yys);
+	return x;
+}
+
+long
+yylex1(void)
+{
+	long yychar;
+	long *t3p;
+	int c;
+
+	yychar = yylex();
+	if(yychar <= 0) {
+		c = yytok1[0];
+		goto out;
+	}
+	if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) {
+		c = yytok1[yychar];
+		goto out;
+	}
+	if(yychar >= YYPRIVATE)
+		if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) {
+			c = yytok2[yychar-YYPRIVATE];
+			goto out;
+		}
+	for(t3p=yytok3;; t3p+=2) {
+		c = t3p[0];
+		if(c == yychar) {
+			c = t3p[1];
+			goto out;
+		}
+		if(c == 0)
+			break;
+	}
+	c = 0;
+
+out:
+	if(c == 0)
+		c = yytok2[1];	/* unknown char */
+	if(yydebug >= 3)
+		fprint(2, "lex %.4lux %s\n", yychar, yytokname(c));
+	return c;
+}
+
+int
+yyparse(void)
+{
+	struct
+	{
+		YYSTYPE	yyv;
+		int	yys;
+	} yys[YYMAXDEPTH], *yyp, *yypt;
+	short *yyxi;
+	int yyj, yym, yystate, yyn, yyg;
+	long yychar;
+	YYSTYPE save1, save2;
+	int save3, save4;
+
+	save1 = yylval;
+	save2 = yyval;
+	save3 = yynerrs;
+	save4 = yyerrflag;
+
+	yystate = 0;
+	yychar = -1;
+	yynerrs = 0;
+	yyerrflag = 0;
+	yyp = &yys[-1];
+	goto yystack;
+
+ret0:
+	yyn = 0;
+	goto ret;
+
+ret1:
+	yyn = 1;
+	goto ret;
+
+ret:
+	yylval = save1;
+	yyval = save2;
+	yynerrs = save3;
+	yyerrflag = save4;
+	return yyn;
+
+yystack:
+	/* put a state and value onto the stack */
+	if(yydebug >= 4)
+		fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
+
+	yyp++;
+	if(yyp >= &yys[YYMAXDEPTH]) {
+		yyerror("yacc stack overflow");
+		goto ret1;
+	}
+	yyp->yys = yystate;
+	yyp->yyv = yyval;
+
+yynewstate:
+	yyn = yypact[yystate];
+	if(yyn <= YYFLAG)
+		goto yydefault; /* simple state */
+	if(yychar < 0)
+		yychar = yylex1();
+	yyn += yychar;
+	if(yyn < 0 || yyn >= YYLAST)
+		goto yydefault;
+	yyn = yyact[yyn];
+	if(yychk[yyn] == yychar) { /* valid shift */
+		yychar = -1;
+		yyval = yylval;
+		yystate = yyn;
+		if(yyerrflag > 0)
+			yyerrflag--;
+		goto yystack;
+	}
+
+yydefault:
+	/* default state action */
+	yyn = yydef[yystate];
+	if(yyn == -2) {
+		if(yychar < 0)
+			yychar = yylex1();
+
+		/* look through exception table */
+		for(yyxi=yyexca;; yyxi+=2)
+			if(yyxi[0] == -1 && yyxi[1] == yystate)
+				break;
+		for(yyxi += 2;; yyxi += 2) {
+			yyn = yyxi[0];
+			if(yyn < 0 || yyn == yychar)
+				break;
+		}
+		yyn = yyxi[1];
+		if(yyn < 0)
+			goto ret0;
+	}
+	if(yyn == 0) {
+		/* error ... attempt to resume parsing */
+		switch(yyerrflag) {
+		case 0:   /* brand new error */
+			yyerror("syntax error");
+			yynerrs++;
+			if(yydebug >= 1) {
+				fprint(2, "%s", yystatname(yystate));
+				fprint(2, "saw %s\n", yytokname(yychar));
+			}
+
+		case 1:
+		case 2: /* incompletely recovered error ... try again */
+			yyerrflag = 3;
+
+			/* find a state where "error" is a legal shift action */
+			while(yyp >= yys) {
+				yyn = yypact[yyp->yys] + YYERRCODE;
+				if(yyn >= 0 && yyn < YYLAST) {
+					yystate = yyact[yyn];  /* simulate a shift of "error" */
+					if(yychk[yystate] == YYERRCODE)
+						goto yystack;
+				}
+
+				/* the current yyp has no shift onn "error", pop stack */
+				if(yydebug >= 2)
+					fprint(2, "error recovery pops state %d, uncovers %d\n",
+						yyp->yys, (yyp-1)->yys );
+				yyp--;
+			}
+			/* there is no state on the stack with an error shift ... abort */
+			goto ret1;
+
+		case 3:  /* no shift yet; clobber input char */
+			if(yydebug >= 2)
+				fprint(2, "error recovery discards %s\n", yytokname(yychar));
+			if(yychar == YYEOFCODE)
+				goto ret1;
+			yychar = -1;
+			goto yynewstate;   /* try again in the same state */
+		}
+	}
+
+	/* reduction by production yyn */
+	if(yydebug >= 2)
+		fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
+
+	yypt = yyp;
+	yyp -= yyr2[yyn];
+	yyval = (yyp+1)->yyv;
+	yym = yyn;
+
+	/* consult goto table to find next state */
+	yyn = yyr1[yyn];
+	yyg = yypgo[yyn];
+	yyj = yyg + yyp->yys + 1;
+
+	if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
+		yystate = yyact[yyg];
+	switch(yym) {
+		
+case 1:
+#line	74	"limbo.y"
+{
+		impmods = yypt[-1].yyv.ids;
+	} break;
+case 2:
+#line	77	"limbo.y"
+{
+		tree = rotater(yypt[-0].yyv.node);
+	} break;
+case 3:
+#line	81	"limbo.y"
+{
+		impmods = nil;
+		tree = rotater(yypt[-0].yyv.node);
+	} break;
+case 5:
+#line	89	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else if(yypt[-0].yyv.node == nil)
+			yyval.node = yypt[-1].yyv.node;
+		else
+			yyval.node = mkbin(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 6:
+#line	100	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 11:
+#line	108	"limbo.y"
+{
+		yyval.node = mkbin(Oas, yypt[-3].yyv.node, yypt[-1].yyv.node);
+	} break;
+case 12:
+#line	112	"limbo.y"
+{
+		yyval.node = mkbin(Oas, yypt[-3].yyv.node, yypt[-1].yyv.node);
+	} break;
+case 13:
+#line	116	"limbo.y"
+{
+		yyval.node = mkbin(Odas, yypt[-3].yyv.node, yypt[-1].yyv.node);
+	} break;
+case 14:
+#line	120	"limbo.y"
+{
+		yyval.node = mkbin(Odas, yypt[-3].yyv.node, yypt[-1].yyv.node);
+	} break;
+case 15:
+#line	124	"limbo.y"
+{
+		yyerror("illegal declaration");
+		yyval.node = nil;
+	} break;
+case 16:
+#line	129	"limbo.y"
+{
+		yyerror("illegal declaration");
+		yyval.node = nil;
+	} break;
+case 18:
+#line	137	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 19:
+#line	143	"limbo.y"
+{
+		includef(yypt[-1].yyv.tok.v.idval);
+		yyval.node = nil;
+	} break;
+case 20:
+#line	148	"limbo.y"
+{
+		yyval.node = typedecl(yypt[-4].yyv.ids, yypt[-1].yyv.type);
+	} break;
+case 21:
+#line	152	"limbo.y"
+{
+		yyval.node = importdecl(yypt[-1].yyv.node, yypt[-4].yyv.ids);
+		yyval.node->src.start = yypt[-4].yyv.ids->src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 22:
+#line	158	"limbo.y"
+{
+		yyval.node = vardecl(yypt[-3].yyv.ids, yypt[-1].yyv.type);
+	} break;
+case 23:
+#line	162	"limbo.y"
+{
+		yyval.node = mkbin(Ovardecli, vardecl(yypt[-5].yyv.ids, yypt[-3].yyv.type), varinit(yypt[-5].yyv.ids, yypt[-1].yyv.node));
+	} break;
+case 24:
+#line	166	"limbo.y"
+{
+		yyval.node = condecl(yypt[-4].yyv.ids, yypt[-1].yyv.node);
+	} break;
+case 26:
+#line	173	"limbo.y"
+{
+		yyval.node = exdecl(yypt[-3].yyv.ids, nil);
+	} break;
+case 27:
+#line	177	"limbo.y"
+{
+		yyval.node = exdecl(yypt[-6].yyv.ids, revids(yypt[-2].yyv.ids));
+	} break;
+case 28:
+#line	183	"limbo.y"
+{
+		yypt[-5].yyv.ids->src.stop = yypt[-0].yyv.tok.src.stop;
+		yyval.node = moddecl(yypt[-5].yyv.ids, rotater(yypt[-1].yyv.node));
+	} break;
+case 29:
+#line	190	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 30:
+#line	194	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else if(yypt[-0].yyv.node == nil)
+			yyval.node = yypt[-1].yyv.node;
+		else
+			yyval.node = mkn(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 31:
+#line	203	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 32:
+#line	209	"limbo.y"
+{
+		yyval.node = fielddecl(Dglobal, typeids(yypt[-3].yyv.ids, yypt[-1].yyv.type));
+	} break;
+case 34:
+#line	214	"limbo.y"
+{
+		yyval.node = typedecl(yypt[-4].yyv.ids, yypt[-1].yyv.type);
+	} break;
+case 35:
+#line	218	"limbo.y"
+{
+		yyval.node = condecl(yypt[-4].yyv.ids, yypt[-1].yyv.node);
+	} break;
+case 37:
+#line	225	"limbo.y"
+{
+		yypt[-7].yyv.ids->src.stop = yypt[-1].yyv.tok.src.stop;
+		yyval.node = adtdecl(yypt[-7].yyv.ids, rotater(yypt[-2].yyv.node));
+		yyval.node->ty->polys = yypt[-4].yyv.ids;
+		yyval.node->ty->val = rotater(yypt[-0].yyv.node);
+	} break;
+case 38:
+#line	232	"limbo.y"
+{
+		yypt[-10].yyv.ids->src.stop = yypt[-0].yyv.tok.src.stop;
+		yyval.node = adtdecl(yypt[-10].yyv.ids, rotater(yypt[-1].yyv.node));
+		yyval.node->ty->polys = yypt[-7].yyv.ids;
+		yyval.node->ty->val = rotater(yypt[-4].yyv.node);
+	} break;
+case 39:
+#line	241	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 40:
+#line	245	"limbo.y"
+{
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 41:
+#line	251	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 42:
+#line	255	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else if(yypt[-0].yyv.node == nil)
+			yyval.node = yypt[-1].yyv.node;
+		else
+			yyval.node = mkn(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 43:
+#line	264	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 46:
+#line	272	"limbo.y"
+{
+		yyval.node = condecl(yypt[-4].yyv.ids, yypt[-1].yyv.node);
+	} break;
+case 47:
+#line	278	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 48:
+#line	282	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else if(yypt[-0].yyv.node == nil)
+			yyval.node = yypt[-1].yyv.node;
+		else
+			yyval.node = mkn(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 49:
+#line	293	"limbo.y"
+{
+		Decl *d;
+
+		for(d = yypt[-4].yyv.ids; d != nil; d = d->next)
+			d->cyc = 1;
+		yyval.node = fielddecl(Dfield, typeids(yypt[-4].yyv.ids, yypt[-1].yyv.type));
+	} break;
+case 50:
+#line	301	"limbo.y"
+{
+		yyval.node = fielddecl(Dfield, typeids(yypt[-3].yyv.ids, yypt[-1].yyv.type));
+	} break;
+case 51:
+#line	307	"limbo.y"
+{
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 52:
+#line	313	"limbo.y"
+{
+		yypt[-1].yyv.node->right->right = yypt[-0].yyv.node;
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 53:
+#line	318	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 54:
+#line	322	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 55:
+#line	328	"limbo.y"
+{
+		yyval.node = mkn(Opickdecl, nil, mkn(Oseq, fielddecl(Dtag, yypt[-1].yyv.ids), nil));
+		typeids(yypt[-1].yyv.ids, mktype(&yypt[-1].yyv.ids->src.start, &yypt[-1].yyv.ids->src.stop, Tadtpick, nil, nil));
+	} break;
+case 56:
+#line	333	"limbo.y"
+{
+		yypt[-3].yyv.node->right->right = yypt[-2].yyv.node;
+		yyval.node = mkn(Opickdecl, yypt[-3].yyv.node, mkn(Oseq, fielddecl(Dtag, yypt[-1].yyv.ids), nil));
+		typeids(yypt[-1].yyv.ids, mktype(&yypt[-1].yyv.ids->src.start, &yypt[-1].yyv.ids->src.stop, Tadtpick, nil, nil));
+	} break;
+case 57:
+#line	339	"limbo.y"
+{
+		yyval.node = mkn(Opickdecl, nil, mkn(Oseq, fielddecl(Dtag, yypt[-1].yyv.ids), nil));
+		typeids(yypt[-1].yyv.ids, mktype(&yypt[-1].yyv.ids->src.start, &yypt[-1].yyv.ids->src.stop, Tadtpick, nil, nil));
+	} break;
+case 58:
+#line	346	"limbo.y"
+{
+		yyval.ids = revids(yypt[-0].yyv.ids);
+	} break;
+case 59:
+#line	352	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, nil);
+	} break;
+case 60:
+#line	356	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, yypt[-2].yyv.ids);
+	} break;
+case 61:
+#line	362	"limbo.y"
+{
+		yyval.ids = revids(yypt[-0].yyv.ids);
+	} break;
+case 62:
+#line	368	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, nil);
+	} break;
+case 63:
+#line	372	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, yypt[-2].yyv.ids);
+	} break;
+case 64:
+#line	378	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-5].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tfix, nil, nil);
+		yyval.type->val = mkbin(Oseq, yypt[-3].yyv.node, yypt[-1].yyv.node);
+	} break;
+case 65:
+#line	383	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-3].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tfix, nil, nil);
+		yyval.type->val = yypt[-1].yyv.node;
+	} break;
+case 66:
+#line	390	"limbo.y"
+{
+		yyval.types = addtype(yypt[-0].yyv.type, nil);
+	} break;
+case 67:
+#line	394	"limbo.y"
+{
+		yyval.types = addtype(yypt[-0].yyv.type, nil);
+		yypt[-0].yyv.type->flags |= CYCLIC;
+	} break;
+case 68:
+#line	399	"limbo.y"
+{
+		yyval.types = addtype(yypt[-0].yyv.type, yypt[-2].yyv.types);
+	} break;
+case 69:
+#line	403	"limbo.y"
+{
+		yyval.types = addtype(yypt[-0].yyv.type, yypt[-3].yyv.types);
+		yypt[-0].yyv.type->flags |= CYCLIC;
+	} break;
+case 70:
+#line	410	"limbo.y"
+{
+		yyval.type = mkidtype(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 71:
+#line	414	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 72:
+#line	418	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 73:
+#line	422	"limbo.y"
+{
+		yyval.type = mkarrowtype(&yypt[-2].yyv.type->src.start, &yypt[-0].yyv.tok.src.stop, yypt[-2].yyv.type, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 74:
+#line	426	"limbo.y"
+{
+		yyval.type = mkarrowtype(&yypt[-5].yyv.type->src.start, &yypt[-3].yyv.tok.src.stop, yypt[-5].yyv.type, yypt[-3].yyv.tok.v.idval);
+		yyval.type = mkinsttype(&yypt[-5].yyv.type->src, yyval.type, yypt[-1].yyv.types);
+	} break;
+case 75:
+#line	431	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-1].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tref, yypt[-0].yyv.type, nil);
+	} break;
+case 76:
+#line	435	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tchan, yypt[-0].yyv.type, nil);
+	} break;
+case 77:
+#line	439	"limbo.y"
+{
+		if(yypt[-1].yyv.ids->next == nil)
+			yyval.type = yypt[-1].yyv.ids->ty;
+		else
+			yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Ttuple, nil, revids(yypt[-1].yyv.ids));
+	} break;
+case 78:
+#line	446	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tarray, yypt[-0].yyv.type, nil);
+	} break;
+case 79:
+#line	450	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tlist, yypt[-0].yyv.type, nil);
+	} break;
+case 80:
+#line	454	"limbo.y"
+{
+		yypt[-1].yyv.type->src.start = yypt[-3].yyv.tok.src.start;
+		yypt[-1].yyv.type->polys = yypt[-2].yyv.ids;
+		yypt[-1].yyv.type->u.eraises = yypt[-0].yyv.node;
+		yyval.type = yypt[-1].yyv.type;
+	} break;
+case 82:
+#line	476	"limbo.y"
+{
+		yyval.type = mkidtype(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 83:
+#line	480	"limbo.y"
+{
+		yyval.type = mkinsttype(&yypt[-3].yyv.tok.src, mkidtype(&yypt[-3].yyv.tok.src, yypt[-3].yyv.tok.v.idval), yypt[-1].yyv.types);
+	} break;
+case 84:
+#line	486	"limbo.y"
+{
+		yyval.type = mkdottype(&yypt[-2].yyv.type->src.start, &yypt[-0].yyv.tok.src.stop, yypt[-2].yyv.type, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 85:
+#line	490	"limbo.y"
+{
+		yyval.type = mkdottype(&yypt[-5].yyv.type->src.start, &yypt[-3].yyv.tok.src.stop, yypt[-5].yyv.type, yypt[-3].yyv.tok.v.idval);
+		yyval.type = mkinsttype(&yypt[-5].yyv.type->src, yyval.type, yypt[-1].yyv.types);
+	} break;
+case 86:
+#line	497	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.type->src, nil, yypt[-0].yyv.type, nil);
+	} break;
+case 87:
+#line	501	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-2].yyv.ids->src, nil, yypt[-0].yyv.type, yypt[-2].yyv.ids);
+	} break;
+case 88:
+#line	507	"limbo.y"
+{
+		yyval.ids = nil;
+	} break;
+case 89:
+#line	511	"limbo.y"
+{
+		yyval.ids = polydecl(yypt[-1].yyv.ids);
+	} break;
+case 90:
+#line	517	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tfn, tnone, yypt[-1].yyv.ids);
+	} break;
+case 91:
+#line	521	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tfn, tnone, nil);
+		yyval.type->varargs = 1;
+	} break;
+case 92:
+#line	526	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-4].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tfn, tnone, yypt[-3].yyv.ids);
+		yyval.type->varargs = 1;
+	} break;
+case 93:
+#line	533	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 94:
+#line	537	"limbo.y"
+{
+		yypt[-2].yyv.type->tof = yypt[-0].yyv.type;
+		yypt[-2].yyv.type->src.stop = yypt[-0].yyv.type->src.stop;
+		yyval.type = yypt[-2].yyv.type;
+	} break;
+case 95:
+#line	545	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 96:
+#line	549	"limbo.y"
+{
+		yyval.type = yypt[-4].yyv.type;
+		yyval.type->val = rotater(yypt[-1].yyv.node);
+	} break;
+case 97:
+#line	556	"limbo.y"
+{
+		yyval.ids = nil;
+	} break;
+case 100:
+#line	564	"limbo.y"
+{
+		yyval.ids = appdecls(yypt[-2].yyv.ids, yypt[-0].yyv.ids);
+	} break;
+case 101:
+#line	570	"limbo.y"
+{
+		yyval.ids = typeids(yypt[-2].yyv.ids, yypt[-0].yyv.type);
+	} break;
+case 102:
+#line	574	"limbo.y"
+{
+		Decl *d;
+
+		yyval.ids = typeids(yypt[-2].yyv.ids, yypt[-0].yyv.type);
+		for(d = yyval.ids; d != nil; d = d->next)
+			d->implicit = 1;
+	} break;
+case 103:
+#line	582	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-2].yyv.node->src, enter("junk", 0), yypt[-0].yyv.type, nil);
+		yyval.ids->store = Darg;
+		yyerror("illegal argument declaraion");
+	} break;
+case 104:
+#line	588	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-2].yyv.node->src, enter("junk", 0), yypt[-0].yyv.type, nil);
+		yyval.ids->store = Darg;
+		yyerror("illegal argument declaraion");
+	} break;
+case 105:
+#line	596	"limbo.y"
+{
+		yyval.ids = revids(yypt[-0].yyv.ids);
+	} break;
+case 106:
+#line	602	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, nil);
+		yyval.ids->store = Darg;
+	} break;
+case 107:
+#line	607	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, nil, nil, nil);
+		yyval.ids->store = Darg;
+	} break;
+case 108:
+#line	612	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, yypt[-2].yyv.ids);
+		yyval.ids->store = Darg;
+	} break;
+case 109:
+#line	617	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, nil, nil, yypt[-2].yyv.ids);
+		yyval.ids->store = Darg;
+	} break;
+case 110:
+#line	650	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 111:
+#line	654	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-1].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tref, yypt[-0].yyv.type, nil);
+	} break;
+case 112:
+#line	658	"limbo.y"
+{
+		yyval.type = yypt[-0].yyv.type;
+	} break;
+case 113:
+#line	662	"limbo.y"
+{
+		yyval.type = mktype(&yypt[-1].yyv.tok.src.start, &yypt[-0].yyv.tok.src.stop, Tref, yypt[-0].yyv.type, nil);
+	} break;
+case 114:
+#line	668	"limbo.y"
+{
+		yyval.node = fndecl(yypt[-3].yyv.node, yypt[-2].yyv.type, yypt[-0].yyv.node);
+		nfns++;
+		/* patch up polydecs */
+		if(yypt[-3].yyv.node->op == Odot){
+			if(yypt[-3].yyv.node->right->left != nil){
+				yypt[-2].yyv.type->polys = yypt[-3].yyv.node->right->left->decl;
+				yypt[-3].yyv.node->right->left = nil;
+			}
+			if(yypt[-3].yyv.node->left->op == Oname && yypt[-3].yyv.node->left->left != nil){
+				yyval.node->decl = yypt[-3].yyv.node->left->left->decl;
+				yypt[-3].yyv.node->left->left = nil;
+			}
+		}
+		else{
+			if(yypt[-3].yyv.node->left != nil){
+				yypt[-2].yyv.type->polys = yypt[-3].yyv.node->left->decl;
+				yypt[-3].yyv.node->left = nil;
+			}
+		}
+		yypt[-2].yyv.type->u.eraises = yypt[-1].yyv.node;
+		yyval.node->src = yypt[-3].yyv.node->src;
+	} break;
+case 115:
+#line	694	"limbo.y"
+{
+		yyval.node = mkn(Otuple, rotater(yypt[-1].yyv.node), nil);
+		yyval.node->src.start = yypt[-3].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 116:
+#line	700	"limbo.y"
+{
+		yyval.node = mkn(Otuple, mkunary(Oseq, yypt[-0].yyv.node), nil);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.node->src.stop;
+	} break;
+case 117:
+#line	706	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 118:
+#line	712	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil){
+			yypt[-1].yyv.node = mkn(Onothing, nil, nil);
+			yypt[-1].yyv.node->src.start = curline();
+			yypt[-1].yyv.node->src.stop = yypt[-1].yyv.node->src.start;
+		}
+		yyval.node = rotater(yypt[-1].yyv.node);
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 119:
+#line	723	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+	} break;
+case 120:
+#line	727	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+	} break;
+case 121:
+#line	733	"limbo.y"
+{
+		yyval.node = mkname(&yypt[-1].yyv.tok.src, yypt[-1].yyv.tok.v.idval);
+		if(yypt[-0].yyv.ids != nil){
+			yyval.node->left = mkn(Onothing, nil ,nil);
+			yyval.node->left->decl = yypt[-0].yyv.ids;
+		}
+	} break;
+case 122:
+#line	741	"limbo.y"
+{
+		yyval.node = mkbin(Odot, yypt[-3].yyv.node, mkname(&yypt[-1].yyv.tok.src, yypt[-1].yyv.tok.v.idval));
+		if(yypt[-0].yyv.ids != nil){
+			yyval.node->right->left = mkn(Onothing, nil ,nil);
+			yyval.node->right->left->decl = yypt[-0].yyv.ids;
+		}
+	} break;
+case 123:
+#line	751	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 124:
+#line	755	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else if(yypt[-0].yyv.node == nil)
+			yyval.node = yypt[-1].yyv.node;
+		else
+			yyval.node = mkbin(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 125:
+#line	764	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil)
+			yyval.node = yypt[-0].yyv.node;
+		else
+			yyval.node = mkbin(Oseq, yypt[-1].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 128:
+#line	777	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 129:
+#line	783	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 130:
+#line	789	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 131:
+#line	795	"limbo.y"
+{
+		if(yypt[-1].yyv.node == nil){
+			yypt[-1].yyv.node = mkn(Onothing, nil, nil);
+			yypt[-1].yyv.node->src.start = curline();
+			yypt[-1].yyv.node->src.stop = yypt[-1].yyv.node->src.start;
+		}
+		yyval.node = mkscope(rotater(yypt[-1].yyv.node));
+	} break;
+case 132:
+#line	804	"limbo.y"
+{
+		yyerror("illegal declaration");
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 133:
+#line	811	"limbo.y"
+{
+		yyerror("illegal declaration");
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 134:
+#line	818	"limbo.y"
+{
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 135:
+#line	822	"limbo.y"
+{
+		yyval.node = mkn(Oif, yypt[-2].yyv.node, mkunary(Oseq, yypt[-0].yyv.node));
+		yyval.node->src.start = yypt[-4].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.node->src.stop;
+	} break;
+case 136:
+#line	828	"limbo.y"
+{
+		yyval.node = mkn(Oif, yypt[-4].yyv.node, mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node));
+		yyval.node->src.start = yypt[-6].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.node->src.stop;
+	} break;
+case 137:
+#line	834	"limbo.y"
+{
+		yyval.node = mkunary(Oseq, yypt[-0].yyv.node);
+		if(yypt[-2].yyv.node->op != Onothing)
+			yyval.node->right = yypt[-2].yyv.node;
+		yyval.node = mkbin(Ofor, yypt[-4].yyv.node, yyval.node);
+		yyval.node->decl = yypt[-9].yyv.ids;
+		if(yypt[-6].yyv.node->op != Onothing)
+			yyval.node = mkbin(Oseq, yypt[-6].yyv.node, yyval.node);
+	} break;
+case 138:
+#line	844	"limbo.y"
+{
+		yyval.node = mkn(Ofor, yypt[-2].yyv.node, mkunary(Oseq, yypt[-0].yyv.node));
+		yyval.node->src.start = yypt[-4].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.node->src.stop;
+		yyval.node->decl = yypt[-5].yyv.ids;
+	} break;
+case 139:
+#line	851	"limbo.y"
+{
+		yyval.node = mkn(Odo, yypt[-2].yyv.node, yypt[-5].yyv.node);
+		yyval.node->src.start = yypt[-6].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-1].yyv.tok.src.stop;
+		yyval.node->decl = yypt[-7].yyv.ids;
+	} break;
+case 140:
+#line	858	"limbo.y"
+{
+		yyval.node = mkn(Obreak, nil, nil);
+		yyval.node->decl = yypt[-1].yyv.ids;
+		yyval.node->src = yypt[-2].yyv.tok.src;
+	} break;
+case 141:
+#line	864	"limbo.y"
+{
+		yyval.node = mkn(Ocont, nil, nil);
+		yyval.node->decl = yypt[-1].yyv.ids;
+		yyval.node->src = yypt[-2].yyv.tok.src;
+	} break;
+case 142:
+#line	870	"limbo.y"
+{
+		yyval.node = mkn(Oret, yypt[-1].yyv.node, nil);
+		yyval.node->src = yypt[-2].yyv.tok.src;
+		if(yypt[-1].yyv.node->op == Onothing)
+			yyval.node->left = nil;
+		else
+			yyval.node->src.stop = yypt[-1].yyv.node->src.stop;
+	} break;
+case 143:
+#line	879	"limbo.y"
+{
+		yyval.node = mkn(Ospawn, yypt[-1].yyv.node, nil);
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-1].yyv.node->src.stop;
+	} break;
+case 144:
+#line	885	"limbo.y"
+{
+		yyval.node = mkn(Oraise, yypt[-1].yyv.node, nil);
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-1].yyv.node->src.stop;
+	} break;
+case 145:
+#line	891	"limbo.y"
+{
+		yyval.node = mkn(Ocase, yypt[-3].yyv.node, caselist(yypt[-1].yyv.node, nil));
+		yyval.node->src = yypt[-3].yyv.node->src;
+		yyval.node->decl = yypt[-5].yyv.ids;
+	} break;
+case 146:
+#line	897	"limbo.y"
+{
+		yyval.node = mkn(Oalt, caselist(yypt[-1].yyv.node, nil), nil);
+		yyval.node->src = yypt[-3].yyv.tok.src;
+		yyval.node->decl = yypt[-4].yyv.ids;
+	} break;
+case 147:
+#line	903	"limbo.y"
+{
+		yyval.node = mkn(Opick, mkbin(Odas, mkname(&yypt[-5].yyv.tok.src, yypt[-5].yyv.tok.v.idval), yypt[-3].yyv.node), caselist(yypt[-1].yyv.node, nil));
+		yyval.node->src.start = yypt[-5].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-3].yyv.node->src.stop;
+		yyval.node->decl = yypt[-7].yyv.ids;
+	} break;
+case 148:
+#line	910	"limbo.y"
+{
+		yyval.node = mkn(Oexit, nil, nil);
+		yyval.node->src = yypt[-1].yyv.tok.src;
+	} break;
+case 149:
+#line	915	"limbo.y"
+{
+		if(yypt[-6].yyv.node == nil){
+			yypt[-6].yyv.node = mkn(Onothing, nil, nil);
+			yypt[-6].yyv.node->src.start = curline();
+			yypt[-6].yyv.node->src.stop = curline();
+		}
+		yypt[-6].yyv.node = mkscope(rotater(yypt[-6].yyv.node));
+		yyval.node = mkbin(Oexstmt, yypt[-6].yyv.node, mkn(Oexcept, yypt[-3].yyv.node, caselist(yypt[-1].yyv.node, nil)));
+	} break;
+case 150:
+#line	933	"limbo.y"
+{
+		yyval.ids = nil;
+	} break;
+case 151:
+#line	937	"limbo.y"
+{
+		if(yypt[-1].yyv.ids->next != nil)
+			yyerror("only one identifier allowed in a label");
+		yyval.ids = yypt[-1].yyv.ids;
+	} break;
+case 152:
+#line	945	"limbo.y"
+{
+		yyval.ids = nil;
+	} break;
+case 153:
+#line	949	"limbo.y"
+{
+		yyval.ids = mkids(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval, nil, nil);
+	} break;
+case 154:
+#line	955	"limbo.y"
+{
+		yypt[-1].yyv.node->left->right->right = yypt[-0].yyv.node;
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 155:
+#line	962	"limbo.y"
+{
+		yyval.node = mkunary(Oseq, mkscope(mkunary(Olabel, rotater(yypt[-1].yyv.node))));
+	} break;
+case 156:
+#line	966	"limbo.y"
+{
+		yypt[-3].yyv.node->left->right->right = yypt[-2].yyv.node;
+		yyval.node = mkbin(Oseq, mkscope(mkunary(Olabel, rotater(yypt[-1].yyv.node))), yypt[-3].yyv.node);
+	} break;
+case 157:
+#line	973	"limbo.y"
+{
+		yypt[-1].yyv.node->left->right = mkscope(yypt[-0].yyv.node);
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 158:
+#line	980	"limbo.y"
+{
+		yyval.node = mkunary(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)));
+	} break;
+case 159:
+#line	984	"limbo.y"
+{
+		yypt[-3].yyv.node->left->right = mkscope(yypt[-2].yyv.node);
+		yyval.node = mkbin(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)), yypt[-3].yyv.node);
+	} break;
+case 160:
+#line	991	"limbo.y"
+{
+		yypt[-1].yyv.node->left->right = mkscope(yypt[-0].yyv.node);
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 161:
+#line	998	"limbo.y"
+{
+		yyval.node = mkunary(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)));
+	} break;
+case 162:
+#line	1002	"limbo.y"
+{
+		yypt[-3].yyv.node->left->right = mkscope(yypt[-2].yyv.node);
+		yyval.node = mkbin(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)), yypt[-3].yyv.node);
+	} break;
+case 164:
+#line	1010	"limbo.y"
+{
+		yyval.node = mkbin(Orange, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 165:
+#line	1014	"limbo.y"
+{
+		yyval.node = mkn(Owild, nil, nil);
+		yyval.node->src = yypt[-0].yyv.tok.src;
+	} break;
+case 166:
+#line	1019	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 167:
+#line	1023	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 168:
+#line	1031	"limbo.y"
+{
+		yypt[-1].yyv.node->left->right = mkscope(yypt[-0].yyv.node);
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 169:
+#line	1038	"limbo.y"
+{
+		yyval.node = mkunary(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)));
+	} break;
+case 170:
+#line	1042	"limbo.y"
+{
+		yypt[-3].yyv.node->left->right = mkscope(yypt[-2].yyv.node);
+		yyval.node = mkbin(Oseq, mkunary(Olabel, rotater(yypt[-1].yyv.node)), yypt[-3].yyv.node);
+	} break;
+case 171:
+#line	1049	"limbo.y"
+{
+		yyval.node = mkname(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 172:
+#line	1053	"limbo.y"
+{
+		yyval.node = mkn(Owild, nil, nil);
+		yyval.node->src = yypt[-0].yyv.tok.src;
+	} break;
+case 173:
+#line	1058	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 174:
+#line	1062	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 175:
+#line	1070	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = curline();
+		yyval.node->src.stop = yyval.node->src.start;
+	} break;
+case 178:
+#line	1080	"limbo.y"
+{
+		yyval.node = mkbin(Oas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 179:
+#line	1084	"limbo.y"
+{
+		yyval.node = mkbin(Oandas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 180:
+#line	1088	"limbo.y"
+{
+		yyval.node = mkbin(Ooras, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 181:
+#line	1092	"limbo.y"
+{
+		yyval.node = mkbin(Oxoras, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 182:
+#line	1096	"limbo.y"
+{
+		yyval.node = mkbin(Olshas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 183:
+#line	1100	"limbo.y"
+{
+		yyval.node = mkbin(Orshas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 184:
+#line	1104	"limbo.y"
+{
+		yyval.node = mkbin(Oaddas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 185:
+#line	1108	"limbo.y"
+{
+		yyval.node = mkbin(Osubas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 186:
+#line	1112	"limbo.y"
+{
+		yyval.node = mkbin(Omulas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 187:
+#line	1116	"limbo.y"
+{
+		yyval.node = mkbin(Odivas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 188:
+#line	1120	"limbo.y"
+{
+		yyval.node = mkbin(Omodas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 189:
+#line	1124	"limbo.y"
+{
+		yyval.node = mkbin(Oexpas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 190:
+#line	1128	"limbo.y"
+{
+		yyval.node = mkbin(Osnd, yypt[-3].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 191:
+#line	1132	"limbo.y"
+{
+		yyval.node = mkbin(Odas, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 192:
+#line	1136	"limbo.y"
+{
+		yyval.node = mkn(Oload, yypt[-0].yyv.node, nil);
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.node->src.stop;
+		yyval.node->ty = mkidtype(&yypt[-1].yyv.tok.src, yypt[-1].yyv.tok.v.idval);
+	} break;
+case 193:
+#line	1143	"limbo.y"
+{
+		yyval.node = mkbin(Oexp, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 194:
+#line	1147	"limbo.y"
+{
+		yyval.node = mkbin(Omul, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 195:
+#line	1151	"limbo.y"
+{
+		yyval.node = mkbin(Odiv, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 196:
+#line	1155	"limbo.y"
+{
+		yyval.node = mkbin(Omod, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 197:
+#line	1159	"limbo.y"
+{
+		yyval.node = mkbin(Oadd, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 198:
+#line	1163	"limbo.y"
+{
+		yyval.node = mkbin(Osub, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 199:
+#line	1167	"limbo.y"
+{
+		yyval.node = mkbin(Orsh, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 200:
+#line	1171	"limbo.y"
+{
+		yyval.node = mkbin(Olsh, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 201:
+#line	1175	"limbo.y"
+{
+		yyval.node = mkbin(Olt, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 202:
+#line	1179	"limbo.y"
+{
+		yyval.node = mkbin(Ogt, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 203:
+#line	1183	"limbo.y"
+{
+		yyval.node = mkbin(Oleq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 204:
+#line	1187	"limbo.y"
+{
+		yyval.node = mkbin(Ogeq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 205:
+#line	1191	"limbo.y"
+{
+		yyval.node = mkbin(Oeq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 206:
+#line	1195	"limbo.y"
+{
+		yyval.node = mkbin(Oneq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 207:
+#line	1199	"limbo.y"
+{
+		yyval.node = mkbin(Oand, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 208:
+#line	1203	"limbo.y"
+{
+		yyval.node = mkbin(Oxor, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 209:
+#line	1207	"limbo.y"
+{
+		yyval.node = mkbin(Oor, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 210:
+#line	1211	"limbo.y"
+{
+		yyval.node = mkbin(Ocons, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 211:
+#line	1215	"limbo.y"
+{
+		yyval.node = mkbin(Oandand, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 212:
+#line	1219	"limbo.y"
+{
+		yyval.node = mkbin(Ooror, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 214:
+#line	1226	"limbo.y"
+{
+		yypt[-0].yyv.node->src.start = yypt[-1].yyv.tok.src.start;
+		yyval.node = yypt[-0].yyv.node;
+	} break;
+case 215:
+#line	1231	"limbo.y"
+{
+		yyval.node = mkunary(Oneg, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 216:
+#line	1236	"limbo.y"
+{
+		yyval.node = mkunary(Onot, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 217:
+#line	1241	"limbo.y"
+{
+		yyval.node = mkunary(Ocomp, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 218:
+#line	1246	"limbo.y"
+{
+		yyval.node = mkunary(Oind, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 219:
+#line	1251	"limbo.y"
+{
+		yyval.node = mkunary(Opreinc, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 220:
+#line	1256	"limbo.y"
+{
+		yyval.node = mkunary(Opredec, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 221:
+#line	1261	"limbo.y"
+{
+		yyval.node = mkunary(Orcv, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 222:
+#line	1266	"limbo.y"
+{
+		yyval.node = mkunary(Ohd, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 223:
+#line	1271	"limbo.y"
+{
+		yyval.node = mkunary(Otl, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 224:
+#line	1276	"limbo.y"
+{
+		yyval.node = mkunary(Olen, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 225:
+#line	1281	"limbo.y"
+{
+		yyval.node = mkunary(Oref, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 226:
+#line	1286	"limbo.y"
+{
+		yyval.node = mkunary(Otagof, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+	} break;
+case 227:
+#line	1291	"limbo.y"
+{
+		yyval.node = mkn(Oarray, yypt[-3].yyv.node, nil);
+		yyval.node->ty = mktype(&yypt[-5].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tarray, yypt[-0].yyv.type, nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 228:
+#line	1297	"limbo.y"
+{
+		yyval.node = mkn(Oarray, yypt[-5].yyv.node, yypt[-1].yyv.node);
+		yyval.node->src.start = yypt[-7].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 229:
+#line	1303	"limbo.y"
+{
+		yyval.node = mkn(Onothing, nil, nil);
+		yyval.node->src.start = yypt[-5].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-4].yyv.tok.src.stop;
+		yyval.node = mkn(Oarray, yyval.node, yypt[-1].yyv.node);
+		yyval.node->src.start = yypt[-6].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 230:
+#line	1312	"limbo.y"
+{
+		yyval.node = etolist(yypt[-1].yyv.node);
+		yyval.node->src.start = yypt[-4].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 231:
+#line	1318	"limbo.y"
+{
+		yyval.node = mkn(Ochan, nil, nil);
+		yyval.node->ty = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tchan, yypt[-0].yyv.type, nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 232:
+#line	1324	"limbo.y"
+{
+		yyval.node = mkn(Ochan, yypt[-3].yyv.node, nil);
+		yyval.node->ty = mktype(&yypt[-5].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tchan, yypt[-0].yyv.type, nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 233:
+#line	1330	"limbo.y"
+{
+		yyval.node = mkunary(Ocast, yypt[-0].yyv.node);
+		yyval.node->ty = mktype(&yypt[-3].yyv.tok.src.start, &yypt[-0].yyv.node->src.stop, Tarray, mkidtype(&yypt[-1].yyv.tok.src, yypt[-1].yyv.tok.v.idval), nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 234:
+#line	1336	"limbo.y"
+{
+		yyval.node = mkunary(Ocast, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+		yyval.node->ty = mkidtype(&yyval.node->src, yypt[-1].yyv.tok.v.idval);
+	} break;
+case 235:
+#line	1342	"limbo.y"
+{
+		yyval.node = mkunary(Ocast, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+		yyval.node->ty = mkidtype(&yyval.node->src, yypt[-1].yyv.tok.v.idval);
+	} break;
+case 236:
+#line	1348	"limbo.y"
+{
+		yyval.node = mkunary(Ocast, yypt[-0].yyv.node);
+		yyval.node->src.start = yypt[-1].yyv.tok.src.start;
+		yyval.node->ty = yypt[-1].yyv.type;
+	} break;
+case 238:
+#line	1357	"limbo.y"
+{
+		yyval.node = mkn(Ocall, yypt[-3].yyv.node, yypt[-1].yyv.node);
+		yyval.node->src.start = yypt[-3].yyv.node->src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 239:
+#line	1363	"limbo.y"
+{
+		yyval.node = yypt[-1].yyv.node;
+		if(yypt[-1].yyv.node->op == Oseq)
+			yyval.node = mkn(Otuple, rotater(yypt[-1].yyv.node), nil);
+		else
+			yyval.node->flags |= PARENS;
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 240:
+#line	1373	"limbo.y"
+{
+		yyval.node = mkbin(Odot, yypt[-2].yyv.node, mkname(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval));
+	} break;
+case 241:
+#line	1377	"limbo.y"
+{
+		yyval.node = mkbin(Omdot, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 242:
+#line	1381	"limbo.y"
+{
+		yyval.node = mkbin(Oindex, yypt[-3].yyv.node, yypt[-1].yyv.node);
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 243:
+#line	1386	"limbo.y"
+{
+		if(yypt[-3].yyv.node->op == Onothing)
+			yypt[-3].yyv.node->src = yypt[-2].yyv.tok.src;
+		if(yypt[-1].yyv.node->op == Onothing)
+			yypt[-1].yyv.node->src = yypt[-2].yyv.tok.src;
+		yyval.node = mkbin(Oslice, yypt[-5].yyv.node, mkbin(Oseq, yypt[-3].yyv.node, yypt[-1].yyv.node));
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 244:
+#line	1395	"limbo.y"
+{
+		yyval.node = mkunary(Oinc, yypt[-1].yyv.node);
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 245:
+#line	1400	"limbo.y"
+{
+		yyval.node = mkunary(Odec, yypt[-1].yyv.node);
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 246:
+#line	1405	"limbo.y"
+{
+		yyval.node = mksconst(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 247:
+#line	1409	"limbo.y"
+{
+		yyval.node = mkconst(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.ival);
+		if(yypt[-0].yyv.tok.v.ival > 0x7fffffff || yypt[-0].yyv.tok.v.ival < -0x7fffffff)
+			yyval.node->ty = tbig;
+		yyval.node = yyval.node;
+	} break;
+case 248:
+#line	1416	"limbo.y"
+{
+		yyval.node = mkrconst(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.rval);
+	} break;
+case 249:
+#line	1420	"limbo.y"
+{
+		yyval.node = mkbin(Oindex, yypt[-5].yyv.node, rotater(mkbin(Oseq, yypt[-3].yyv.node, yypt[-1].yyv.node)));
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 250:
+#line	1427	"limbo.y"
+{
+		yyval.node = mkname(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 251:
+#line	1431	"limbo.y"
+{
+		yyval.node = mknil(&yypt[-0].yyv.tok.src);
+	} break;
+case 252:
+#line	1437	"limbo.y"
+{
+		yyval.node = mkn(Otuple, rotater(yypt[-1].yyv.node), nil);
+		yyval.node->src.start = yypt[-2].yyv.tok.src.start;
+		yyval.node->src.stop = yypt[-0].yyv.tok.src.stop;
+	} break;
+case 254:
+#line	1446	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 257:
+#line	1456	"limbo.y"
+{
+		yyval.node = mkn(Otype, nil, nil);
+		yyval.node->ty = mkidtype(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 258:
+#line	1462	"limbo.y"
+{
+		yyval.node = mkn(Otype, nil, nil);
+		yyval.node->ty = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tarray, yypt[-0].yyv.type, nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 259:
+#line	1468	"limbo.y"
+{
+		yyval.node = mkn(Otype, nil, nil);
+		yyval.node->ty = mktype(&yypt[-2].yyv.tok.src.start, &yypt[-0].yyv.type->src.stop, Tlist, yypt[-0].yyv.type, nil);
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 260:
+#line	1474	"limbo.y"
+{
+		yyval.node = mkn(Otype, nil ,nil);
+		yyval.node->ty = yypt[-0].yyv.type;
+		yyval.node->ty->flags |= CYCLIC;
+		yyval.node->src = yyval.node->ty->src;
+	} break;
+case 261:
+#line	1483	"limbo.y"
+{
+		yyval.node = mkname(&yypt[-0].yyv.tok.src, yypt[-0].yyv.tok.v.idval);
+	} break;
+case 262:
+#line	1487	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 265:
+#line	1495	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 266:
+#line	1499	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 267:
+#line	1505	"limbo.y"
+{
+		yyval.node = nil;
+	} break;
+case 268:
+#line	1509	"limbo.y"
+{
+		yyval.node = rotater(yypt[-0].yyv.node);
+	} break;
+case 272:
+#line	1520	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 273:
+#line	1526	"limbo.y"
+{
+		yyval.node = rotater(yypt[-0].yyv.node);
+	} break;
+case 274:
+#line	1530	"limbo.y"
+{
+		yyval.node = rotater(yypt[-1].yyv.node);
+	} break;
+case 276:
+#line	1537	"limbo.y"
+{
+		yyval.node = mkbin(Oseq, yypt[-2].yyv.node, yypt[-0].yyv.node);
+	} break;
+case 277:
+#line	1543	"limbo.y"
+{
+		yyval.node = mkn(Oelem, nil, yypt[-0].yyv.node);
+		yyval.node->src = yypt[-0].yyv.node->src;
+	} break;
+case 278:
+#line	1548	"limbo.y"
+{
+		yyval.node = mkbin(Oelem, rotater(yypt[-2].yyv.node), yypt[-0].yyv.node);
+	} break;
+case 279:
+#line	1573	"limbo.y"
+{
+		if(yypt[-1].yyv.node->op == Oseq)
+			yypt[-1].yyv.node->right->left = rotater(yypt[-0].yyv.node);
+		else
+			yypt[-1].yyv.node->left = rotater(yypt[-0].yyv.node);
+		yyval.node = yypt[-1].yyv.node;
+	} break;
+case 280:
+#line	1583	"limbo.y"
+{
+		yyval.node = typedecl(yypt[-1].yyv.ids, mktype(&yypt[-1].yyv.ids->src.start, &yypt[-0].yyv.tok.src.stop, Tpoly, nil, nil));
+	} break;
+case 281:
+#line	1587	"limbo.y"
+{
+		if(yypt[-3].yyv.node->op == Oseq)
+			yypt[-3].yyv.node->right->left = rotater(yypt[-2].yyv.node);
+		else
+			yypt[-3].yyv.node->left = rotater(yypt[-2].yyv.node);
+		yyval.node = mkbin(Oseq, yypt[-3].yyv.node, typedecl(yypt[-1].yyv.ids, mktype(&yypt[-1].yyv.ids->src.start, &yypt[-0].yyv.tok.src.stop, Tpoly, nil, nil)));
+	} break;
+	}
+	goto yystack;  /* stack new state and value */
+}
--- /dev/null
+++ b/limbo/y.tab.h
@@ -1,0 +1,90 @@
+
+typedef union 
+{
+	struct{
+		Src	src;
+		union{
+			Sym	*idval;
+			Long	ival;
+			Real	rval;
+		}v;
+	}tok;
+	Decl	*ids;
+	Node	*node;
+	Type	*type;
+	Typelist *types;
+}	YYSTYPE;
+extern	YYSTYPE	yylval;
+#define	Landeq	57346
+#define	Loreq	57347
+#define	Lxoreq	57348
+#define	Llsheq	57349
+#define	Lrsheq	57350
+#define	Laddeq	57351
+#define	Lsubeq	57352
+#define	Lmuleq	57353
+#define	Ldiveq	57354
+#define	Lmodeq	57355
+#define	Lexpeq	57356
+#define	Ldeclas	57357
+#define	Lload	57358
+#define	Loror	57359
+#define	Landand	57360
+#define	Lcons	57361
+#define	Leq	57362
+#define	Lneq	57363
+#define	Lleq	57364
+#define	Lgeq	57365
+#define	Llsh	57366
+#define	Lrsh	57367
+#define	Lexp	57368
+#define	Lcomm	57369
+#define	Linc	57370
+#define	Ldec	57371
+#define	Lof	57372
+#define	Lref	57373
+#define	Lif	57374
+#define	Lelse	57375
+#define	Lfn	57376
+#define	Lexcept	57377
+#define	Lraises	57378
+#define	Lmdot	57379
+#define	Lto	57380
+#define	Lor	57381
+#define	Lrconst	57382
+#define	Lconst	57383
+#define	Lid	57384
+#define	Ltid	57385
+#define	Lsconst	57386
+#define	Llabs	57387
+#define	Lnil	57388
+#define	Llen	57389
+#define	Lhd	57390
+#define	Ltl	57391
+#define	Ltagof	57392
+#define	Limplement	57393
+#define	Limport	57394
+#define	Linclude	57395
+#define	Lcon	57396
+#define	Ltype	57397
+#define	Lmodule	57398
+#define	Lcyclic	57399
+#define	Ladt	57400
+#define	Larray	57401
+#define	Llist	57402
+#define	Lchan	57403
+#define	Lself	57404
+#define	Ldo	57405
+#define	Lwhile	57406
+#define	Lfor	57407
+#define	Lbreak	57408
+#define	Lalt	57409
+#define	Lcase	57410
+#define	Lpick	57411
+#define	Lcont	57412
+#define	Lreturn	57413
+#define	Lexit	57414
+#define	Lspawn	57415
+#define	Lraise	57416
+#define	Lfix	57417
+#define	Ldynamic	57418
--- a/locale/timezone
+++ b/locale/timezone
@@ -1,19 +1,24 @@
-GMT 0 BST 3600
- 512528400  530672400  543978000  562122000  575427600  593571600
- 606877200  625626000  638326800  657075600  670381200  688525200
- 701830800  719974800  733280400  751424400  764730000  782874000
- 796179600  814928400  828234000  846378000  859683600  877827600
- 891133200  909277200  922582800  940726800  954032400  972781200
- 985482000 1004230800 1017536400 1035680400 1048986000 1067130000
-1080435600 1099184400 1111885200 1130634000 1143334800 1162083600
-1174784400 1193533200 1206838800 1224982800 1238288400 1256432400
-1269738000 1288486800 1301187600 1319936400 1332637200 1351386000
-1364691600 1382835600 1396141200 1414285200 1427590800 1445734800
-1459040400 1477789200 1490490000 1509238800 1521939600 1540688400
-1553994000 1572138000 1585443600 1603587600 1616893200 1635642000
-1648342800 1667091600 1679792400 1698541200 1711846800 1729990800
-1743296400 1761440400 1774746000 1792890000 1806195600 1824944400
-1837645200 1856394000 1869094800 1887843600 1901149200 1919293200
-1932598800 1950742800 1964048400 1982797200 1995498000 2014246800
-2026947600 2045696400 2058397200 2077146000 2090451600 2108595600
-2121901200 2140045200 2147483647
+CST -21600 CDT -18000
+   9943200   25664400   41392800   57718800   73447200   89168400
+ 104896800  120618000  126669600  152067600  162352800  183517200
+ 199245600  215571600  230695200  247021200  262749600  278470800
+ 294199200  309920400  325648800  341370000  357098400  372819600
+ 388548000  404874000  419997600  436323600  452052000  467773200
+ 483501600  499222800  514951200  530672400  544586400  562122000
+ 576036000  594176400  607485600  625626000  638935200  657075600
+ 670989600  688525200  702439200  719974800  733888800  752029200
+ 765338400  783478800  796788000  814928400  828842400  846378000
+ 860292000  877827600  891741600  909277200  923191200  941331600
+ 954640800  972781200  986090400 1004230800 1018144800 1035680400
+1049594400 1067130000 1081044000 1099184400 1112493600 1130634000
+1143943200 1162083600 1173578400 1194141600 1205028000 1225591200
+1236477600 1257040800 1268532000 1289095200 1299981600 1320544800
+1331431200 1351994400 1362880800 1383444000 1394330400 1414893600
+1425780000 1446343200 1457834400 1478397600 1489284000 1509847200
+1520733600 1541296800 1552183200 1572746400 1583632800 1604196000
+1615687200 1636250400 1647136800 1667700000 1678586400 1699149600
+1710036000 1730599200 1741485600 1762048800 1772935200 1793498400
+1804989600 1825552800 1836439200 1857002400 1867888800 1888452000
+1899338400 1919901600 1930788000 1951351200 1962842400 1983405600
+1994292000 2014855200 2025741600 2046304800 2057191200 2077754400
+2088640800 2109204000 2120090400 2140653600
--- a/makemk.sh
+++ b/makemk.sh
@@ -8,8 +8,8 @@
 
 # change these defines as appropriate here or in mkconfig
 # ROOT should be the root of the Inferno tree
-ROOT=/usr/inferno
-SYSTARG=FreeBSD
+ROOT=$HOME/src/purgatorio
+SYSTARG=Linux
 OBJTYPE=386
 SYSTYPE=posix
 
@@ -19,8 +19,8 @@
 PLAT=$ROOT/$SYSTARG/$OBJTYPE
 
 # you might need to adjust the CC, LD, AR, and RANLIB definitions after this point
-CC="p gcc -m32 -c -I$PLAT/include -I$ROOT/include -I$ROOT/utils/include"
-LD="p gcc -m32"
+CC="p cc -m32 -c -I$PLAT/include -I$ROOT/include -I$ROOT/utils/include"
+LD="p cc -m32"
 AR="p ar crvs"
 RANLIB=":"	# some systems still require `ranlib'
 
--- /dev/null
+++ b/opt/misc/appl/bf.b
@@ -1,0 +1,269 @@
+# Interpreter for the canonical esoteric language.
+# Compiles to bytecode, minimal optimizations, done for fun.
+# Pete Elmore (pete at debu dot gs), New Year's Day 2014
+# Released into the public domain.
+
+implement Bf;
+
+include "sys.m"; sys: Sys;
+include "draw.m";
+include "arg.m";
+
+Bf: module {
+	init: fn(nil: ref Draw->Context, args: list of string);
+	ARENASZ: con 1024 * 1024;
+	EXIT, ADD, JZ, JNZ, ADDP, READ, WRITE: con iota;
+};
+
+init(nil: ref Draw->Context, args: list of string)
+{
+	sys = load Sys Sys->PATH;
+	arg := load Arg Arg->PATH;
+
+	arg->init(args);
+	eflag := 0;
+	outputmode := 0;
+	source := "";
+	while ((opt := arg->opt()) != 0) {
+		case opt {
+		'e' =>
+			eflag = 1;
+			source = arg->arg();
+		'd' =>
+			outputmode = 1;
+		'c' =>
+			outputmode = 2;
+		* =>
+			usage();
+		}
+	}
+	args = arg->argv();
+	if(!eflag) {
+		if(len args != 1)
+			usage();
+		else
+			source = readfile(hd args);
+	}
+
+	code := compile(source);
+	case outputmode {
+	0 => execute(code, array[ARENASZ] of { * => byte 0 });
+	1 => sys->print("%s", disassemble(code));
+	2 => sys->print("%s", bf2limbo(code));
+	}
+}
+
+usage()
+{
+	sys->fprint(sys->fildes(2), "usage: bf [-d|-c] [program.bf|-e inline-program]");
+	raise "fail:usage";
+}
+
+compile(p: string): array of int
+{
+	marks: list of int = nil;
+	code := array[len p * 2 + 1] of { * => EXIT };
+	pc := 0;
+	n: int;
+	for(i := 0; i < len p; i++) {
+		case p[i] {
+		'-' or '+' =>
+			n = 0;
+			while(i < len p) {
+				if(p[i] == '-')
+					n--;
+				else if(p[i] == '+')
+					n++;
+				else {
+					i--;
+					break;
+				}
+				i++;
+			}
+			if(n) {
+				code[pc++] = ADD;
+				code[pc++] = n;
+			}
+		'<' or '>' =>
+			n = 0;
+			while(i < len p) {
+				if(p[i] == '<')
+					n--;
+				else if(p[i] == '>')
+					n++;
+				else {
+					i--;
+					break;
+				}
+				i++;
+			}
+			if(n) {
+				code[pc++] = ADDP;
+				code[pc++] = n;
+			}
+		',' => code[pc++] = READ;
+		'.' => code[pc++] = WRITE;
+		'[' =>
+			code[pc++] = JZ;
+			marks = pc++ :: marks;
+		']' =>
+			if(marks == nil) {
+				sys->fprint(sys->fildes(2), "bf: unmatched ']' at character %d.", pc);
+				raise "fail:errors";
+			}
+			c := hd marks;
+			marks = tl marks;
+			code[pc++] = JNZ;
+			code[c] = pc;
+			code[pc++] = c;
+		}
+	}
+	if(marks != nil) {
+		sys->fprint(sys->fildes(2), "bf: unmatched '['.");
+		raise "fail:errors";
+	}
+	return code[:pc + 1];
+}
+
+execute(code: array of int, arena: array of byte)
+{
+	pc := 0;
+	p := 0;
+	buf := array[1] of byte;
+	stopreading := 0;
+	for(;;) {
+		case code[pc] {
+		ADD =>
+			arena[p] += byte code[++pc];
+		ADDP =>
+			p += code[++pc];
+			while(p < 0)
+				p += len arena;
+			p = p % len arena;
+		READ =>
+			arena[p] = byte -1;
+			if(!stopreading) {
+				n := sys->read(sys->fildes(0), buf, 1);
+				if(n < 1)
+					stopreading = 1;
+				else
+					arena[p] = buf[0];
+			}
+		WRITE =>
+			buf[0] = arena[p];
+			sys->write(sys->fildes(1), buf, 1);
+		JNZ =>
+			if(arena[p] != byte 0)
+				pc = code[pc + 1];
+			else
+				pc++;
+		JZ =>
+			if(arena[p] == byte 0)
+				pc = code[pc + 1];
+			else
+				pc++;
+		EXIT => return;
+		}
+		pc++;
+	}
+}
+
+disassemble(code: array of int): string
+{
+	s := "";
+	for(i := 0; i < len code && code[i] != EXIT; i++) {
+		s += sys->sprint("[0x%08x]  0x%02x  ", i, code[i]);
+		case code[i] {
+		ADD => s += sys->sprint("add   %d", code[++i]);
+		ADDP => s += sys->sprint("addp  %d", code[++i]);
+		READ => s += "read ";
+		WRITE => s += "write";
+		JNZ => s += sys->sprint("jnz   0x%08x", code[++i]);
+		JZ => s += sys->sprint("jz    0x%08x", code[++i]);
+		* => s += sys->sprint(">>>>>>BUG %d / 0x%08x", code[i], code[i]);
+		}
+		s += "\n";
+	}
+	return s;
+}
+
+bf2limbo(code: array of int): string
+{
+	indent := 1;
+	s := "implement BfProg;\n" +
+		"include \"sys.m\"; sys: Sys;\n" +
+		"include \"draw.m\";\n" +
+		"BfProg: module {\n" +
+		"\tinit: fn(nil: ref Draw->Context, nil: list of string);\n" +
+		"};\n" +
+		"init(nil: ref Draw->Context, nil: list of string)\n{\n" +
+		"\tsys = load Sys Sys->PATH;\n" +
+		"\tp := 0;\n" +
+		"\tstopreading := 0;\n" +
+		"\tn := 0;\n" +
+		"\tbuf := array[1] of byte;\n" +
+		"\tarena := array[" + string ARENASZ + "] of { * => byte 0 };\n" +
+		"\n";
+	for(i := 0; i < len code && code[i] != EXIT; i++) {
+		case code[i] {
+		ADD => s += indents(indent) + "arena[p] += byte " + string code[++i] + ";\n";
+		ADDP =>
+			s += indents(indent) + "p += " + string code[++i] + ";\n" +
+				indents(indent) + "while(p < 0)\n" +
+				indents(indent + 1) + "p += len arena;\n" +
+				indents(indent) + "p = p % len arena;\n";
+		READ =>
+			s += indents(indent) + "arena[p] = byte -1;\n" +
+				indents(indent) + "if(!stopreading) {\n" +
+				indents(indent + 1) + "n = sys->read(sys->fildes(0), buf, 1);\n" +
+				indents(indent + 1) + "if(n < 1)\n" +
+				indents(indent + 2) + "stopreading = 1;\n" +
+				indents(indent + 1) + "else\n" +
+				indents(indent + 2) + "arena[p] = buf[0];\n" +
+				indents(indent) + "}\n";
+		WRITE =>
+			s += indents(indent) + "buf[0] = arena[p];\n" +
+				indents(indent) + "sys->write(sys->fildes(1), buf, 1);\n";
+		JNZ =>
+			indent--;
+			s += indents(indent) + "}\n";
+			i++;
+		JZ =>
+			s += indents(indent) + "while(arena[p] != byte 0) {\n";
+			indent++;
+			i++;
+		}
+		
+	}
+	return s + "}\n";
+}
+
+indents(i: int): string
+{
+	r := "";
+	while(i > 0) {
+		r += "\t";
+		i--;
+	}
+	return r;
+}
+
+readfile(fname: string): string
+{
+	fd := sys->open(fname, Sys->OREAD);
+	if(fd == nil)
+		die(fname);
+
+	src := "";
+	buf := array[Sys->ATOMICIO] of byte;
+	while((n := sys->read(fd, buf, len buf)) > 0) {
+		src += string buf[:n];
+	}
+	return src;
+}
+
+die(s: string)
+{
+	sys->fprint(sys->fildes(2), "bf: %s: %r\n", s);
+	raise "fail:errors";
+}
\ No newline at end of file
--- /dev/null
+++ b/opt/misc/appl/hello.b
@@ -1,0 +1,15 @@
+implement Hello;
+
+include "sys.m";
+	sys: Sys;
+include "draw.m";
+
+Hello: module {
+	init:
+	fn(ctxt: ref Draw->Context, argv: list of string);
+};
+
+init(ctxt : ref Draw->Context, argv: list of string) {
+	sys = load Sys Sys->PATH;
+	sys->print("Hello World!\n");
+}
binary files /dev/null b/opt/misc/dis/bf.dis differ
binary files /dev/null b/opt/misc/dis/hello.dis differ
--- /dev/null
+++ b/opt/mkfiles/README.md
@@ -1,0 +1,49 @@
+# Description
+
+These mkfiles can be used as is or as basis for your own mkfiles. Unlike
+standard files in `/mkfiles` these know how to handle `/opt` packages;
+able to build/run tests (both in host os and inside emu) and have other
+features (generation of INDEX files for your man pages, generation of man
+pages from text in asciidoc markup, etc.).
+
+
+# Install
+
+Make directory with these files available in /opt/mkfiles.
+
+Install system-wide:
+
+```
+# git clone https://github.com/powerman/inferno-opt-mkfiles.git $INFERNO_ROOT/opt/mkfiles
+```
+
+or in your home directory:
+
+```
+$ git clone https://github.com/powerman/inferno-opt-mkfiles.git $INFERNO_USER_HOME/opt/mkfiles
+$ emu
+; bind opt /opt
+```
+
+or locally for your project:
+
+```
+$ git clone https://github.com/powerman/inferno-opt-mkfiles.git $YOUR_PROJECT_DIR/opt/mkfiles
+$ emu
+; cd $YOUR_PROJECT_DIR_INSIDE_EMU
+; bind opt /opt
+```
+
+
+# Usage
+
+Start your new project using these mkfiles:
+
+```
+$ emu
+; mkdir newproject
+; cd newproject
+; cp /opt/mkfiles/mkconfig-example mkconfig
+; cp /opt/mkfiles/mkfile-example mkfile
+```
+
--- /dev/null
+++ b/opt/mkfiles/mkasciidoc
@@ -1,0 +1,43 @@
+# MANDIR=$PKGDIR/man/2
+# 
+# MANTARG=\
+# 	somelib\
+# 
+
+KEEPMTIME=${OSTARG:Inferno=-x}
+KEEPMTIME=${KEEPMTIME:os=-p}
+
+all:V:			${MANTARG:%=%.man}
+
+install:V:		${MANTARG:%=$MANDIR/%}
+
+test:V:			install
+
+clean:V:
+	rm -f *.man
+
+nuke:V:			clean
+	cd $MANDIR; rm -f $MANTARG
+
+%.man:N:		%.man-$OSTARG
+
+%.man-Inferno:QV:	%.txt
+	echo 'Require asciidoc (run mk install in host os)'
+	raise 'not implemented'
+
+%.man-os:QV:		%.txt
+	if ! asciidoc 2>/dev/null; then
+	    echo 'Require asciidoc: http://www.methods.co.nz/asciidoc/'
+	    false
+	elif ! asciidoc --backend list 2>/dev/null | grep -q 9man; then
+	    echo 'Require 9man backend for asciidoc: http://powerman.name/asciidoc/'
+	    false
+	else
+	    echo asciidoc -d manpage -b 9man $stem.txt
+	    asciidoc -d manpage -b 9man $stem.txt 
+	    # avoid redundant INDEX regen on next mk all
+	    touch -c -r $stem.txt -d '+1 second' $stem.man
+	fi
+
+$MANDIR/%:		%.man
+	rm -f $MANDIR/$stem && cp $KEEPMTIME $stem.man $MANDIR/$stem
--- /dev/null
+++ b/opt/mkfiles/mkconfig-example
@@ -1,0 +1,26 @@
+<$ROOT/mkconfig
+
+
+# PKGDIR: [host,emu] path to project's root (from mkfile's dir).
+# Used to run tests. Also very useful to simplify paths in any mkfile.
+PKGDIR=$PKGDIR	# MUST BE SET IN EVERY mkfile BEFORE INCLUDING THIS mkconfig!
+
+# OPTDIR: [host,emu] path to dir with opt/ subdir (from mkfile's dir).
+# Used to find modules by relative path (e.g. opt/powerman/tap/module/t.m).
+OPTDIR=${OSTARG:Inferno=/}
+OPTDIR=${OPTDIR:os=$INFERNO_HOME}
+
+# MKFILES: [host,emu] path to mkfiles/ dir (from mkfile's dir).
+# Used to find helper files needed by some mkfiles and ease including them.
+MKFILES=$OPTDIR/opt/mkfiles
+
+# EMUCMD: command to run .dis file from host os.
+# EMUPKGDIR: [emu] path to project's root (from $EMUCMD's dir).
+# Used to run tests from host os (e.g. $EMUCMD $EMUPKGDIR/appl/lib/t/smoke.dis).
+EMUCMD='emu-g sh -c "run /lib/sh/profile; \$1; shutdown -h"'
+EMUPKGDIR=/opt/YOURNAME/YOURPACKAGE
+
+
+# Default target (first target in first loaded mkfile).
+usage:QV:
+    echo mk all, install, test, clean or nuke
--- /dev/null
+++ b/opt/mkfiles/mkdis
@@ -1,0 +1,42 @@
+# DISBIN=$PKGDIR/dis/lib
+# 
+# TARG=\
+# 	somelib.dis\
+# 
+# SYSMODULES=\
+# 	sys.m\
+# 
+# OPTMODULES=\
+#	opt/powerman/hashtable/module/hashtable.m\
+# 
+# MODULES=\
+# 	$PKGDIR/module/somelib.m\
+# 
+
+MODDIR=$ROOT/module
+SYS_MODULE=${SYSMODULES:%=$MODDIR/%}
+OPT_MODULE=${OPTMODULES:%=$OPTDIR/%}
+LIMBOFLAGS=-I$MODDIR -I$OPTDIR
+
+all:V:			$TARG
+
+install:V:		${TARG:%=$DISBIN/%}
+
+test:V:			install
+
+clean:V:
+	rm -f *.dis *.sbl *.s
+
+nuke:V:			clean
+	cd $DISBIN; rm -f $TARG
+
+%.dis:			$MODULES $SYS_MODULE $OPT_MODULE
+
+%.dis:			%.b
+	limbo $LIMBOFLAGS -gw $stem.b
+
+%.s:			%.b
+	limbo $LIMBOFLAGS -w -G -S $stem.b
+
+$DISBIN/%.dis:		%.dis
+	rm -f $DISBIN/$stem.dis && cp $stem.dis $DISBIN/$stem.dis
--- /dev/null
+++ b/opt/mkfiles/mkfile-example
@@ -1,0 +1,10 @@
+PKGDIR=.
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	appl\
+	doc\
+	man\
+
+<$MKFILES/mksubdirs
--- /dev/null
+++ b/opt/mkfiles/mkindices
@@ -1,0 +1,73 @@
+# MANDIRS=\
+# 	2\
+# 
+
+MKINDICES=$MKFILES/mkindices
+
+all:V:			indices-$OSTARG
+
+install:V:		all
+
+test:V:			install
+
+clean:V:		${MANDIRS:%=clean-%}
+
+clean-%:V:
+	rm -f $stem/INDEX
+
+nuke:V:			clean
+
+indices-Inferno:QV:
+	MKINDICESABS=`{ cleanname -d `{pwd} $"MKINDICES }
+	for j in $MANDIRS {
+		if { ftest -d $j } {
+			echo cd $j'; mk -f' $MKINDICES $MKFLAGS 'MANPAGES=… INDEX'
+			@{ pctl forkns; cd $j; mk -f $MKINDICESABS $MKFLAGS 'MANPAGES=`{ ls | grep -v ''^INDEX$'' }' INDEX }
+		} {
+			! ftest -e $j || raise $j^' not a directory'
+		}
+	}
+
+indices-os:QV:
+	MKINDICESABS=$(realpath $MKINDICES)
+	for j in $MANDIRS; do
+		if test -d $j; then
+			echo cd $j'; mk -f' $MKINDICES $MKFLAGS 'MANPAGES=… INDEX'
+			(cd $j; mk -f $MKINDICESABS $MKFLAGS "MANPAGES=$(echo $(ls | grep -v '^INDEX$'))" INDEX) || exit 1
+		else
+			test ! -e $j || { echo $j not a directory; exit 1; }
+		fi
+	done
+
+INDEX:N:		INDEX-$OSTARG
+
+INDEX-Inferno:QEV:	$MANPAGES
+	test -z $"prereq || {
+		echo 'generating INDEX'
+		# /man/*/INDEX generator by Pete Elmore
+		load regex
+		for f in $prereq {
+			ws := ${re sg '0intro' 'intro' $f}
+			h := ()
+			getlines {
+				(s n rest) := ${split ' ' $line}
+				if {~ $s .SH}	{h = $n; raise continue}
+				if {no $h}	{raise continue}
+				if {~ $h NAME}	{ws = $ws $line}	{raise break}
+			} < $f
+			ws = `{echo ${re sg '( |\\)-.*' '' $"ws} | tr A-Z a-z | tr -dc 'a-z0-9_/!~. -'}
+			for w in $ws {echo $w $f} | sort
+		} | uniq >INDEX
+	}
+
+INDEX-os:QV:		$MANPAGES
+	if test -n "$prereq"; then
+		echo 'generating INDEX'
+		perl -0777 -ne '
+			s/\A.*?^\.SH\s+NAME\s*\n(.*?)^\.SH\s.*/$1/ms;
+			s/(?:\s|\\)-.*//ms;
+			$f=$ARGV;
+			$f=~s/0intro/intro/ms;
+			print "$_ $ARGV\n" for sort map {lc} $f, /([\w\/!~.-]+)/msg;
+		' $prereq | uniq >INDEX
+	fi
--- /dev/null
+++ b/opt/mkfiles/mksubdirs
@@ -1,0 +1,30 @@
+# DIRS=\
+# 	subdir1\
+# 	subdir2\
+# 
+
+all:V:			all-$SHELLTYPE
+install:V:		install-$SHELLTYPE
+test:V:			test-$SHELLTYPE
+clean:V:		clean-$SHELLTYPE
+nuke:V:			nuke-$SHELLTYPE
+
+%-rc:QV:
+	for j in $DIRS {
+		if { ftest -d $j } {
+			echo cd $j'; mk' $MKFLAGS $stem
+			@{ pctl forkns; cd $j; mk $MKFLAGS $stem }
+		} {
+			! ftest -e $j || raise $j' not a directory'
+		}
+	}
+
+%-sh:QV:
+	for j in $DIRS; do
+		if test -d $j; then
+			echo cd $j'; mk' $MKFLAGS $stem
+			(cd $j; mk $MKFLAGS $stem) || exit 1
+		else
+			test ! -e $j || { echo $j not a directory; exit 1; }
+		fi
+	done
--- /dev/null
+++ b/opt/mkfiles/mktest
@@ -1,0 +1,51 @@
+# TESTS=\
+# 	smoke.dis\
+# 	sometest.dis\
+# 
+# TESTTARG=\
+# 	share.dis\
+# 
+# SYSMODULES=\
+# 	sys.m\
+# 	draw.m\
+# 
+# OPTMODULES=\
+#	opt/powerman/tap/module/t.m\
+#	opt/powerman/tap/module/tap.m\
+# 
+# MODULES=\
+# 	$PKGDIR/module/somelib.m\
+# 
+
+MODDIR=$ROOT/module
+SYS_MODULE=${SYSMODULES:%=$MODDIR/%}
+OPT_MODULE=${OPTMODULES:%=$OPTDIR/%}
+LIMBOFLAGS=-I$MODDIR -I$OPTDIR
+
+all:V:			$TESTTARG $TESTS ${TESTS:%.dis=%.t}
+
+install:V:		all
+
+test:V:			install ${TESTS:%.dis=%.test-$OSTARG}
+
+clean:V:
+	rm -f *.dis *.sbl *.s *.t
+
+nuke:V:			clean
+
+%.dis:			$MODULES $SYS_MODULE $OPT_MODULE
+
+%.dis:			%.b
+	limbo $LIMBOFLAGS -gw $stem.b
+
+%.s:			%.b
+	limbo $LIMBOFLAGS -w -G -S $stem.b
+
+%.t:			$MKFILES/runtest.sh
+	cp $MKFILES/runtest.sh $stem.t
+
+%.test-Inferno:V:
+	d=`{pwd}; cd $PKGDIR; $d/$stem.dis
+
+%.test-os:V:
+	./$stem.t
--- /dev/null
+++ b/opt/mkfiles/runtest.sh
@@ -1,0 +1,20 @@
+#!/bin/bash -i
+# This script designed to be executed from host os in any way:
+#	cd /…/project;	prove -r; mk test; appl/lib/t/smoke.t
+#	cd appl/lib;	prove -r; mk test; t/smoke.t
+#	cd t;		prove -r; mk test; ./smoke.t
+# It require PKGDIR, EMUPKGDIR and EMUCMD variables set in mkfile.
+
+# When this script executed not by mk (i.e. by prove or manually) it won't
+# have variables from mkfile in environment and will need to fetch them.
+function getvar() {
+	echo -e "<mkfile\ngetvar:VQ:\n\techo \$$1" |
+		mk -f /proc/self/fd/0 getvar
+}
+
+SUBDIR=$(pwd)
+cd $(getvar PKGDIR)
+PKGDIR=$(pwd)
+DIS=$(getvar EMUPKGDIR)${SUBDIR:${#PKGDIR}}/$(dirname $0)/$(basename $0 .t).dis
+
+eval "$(getvar EMUCMD) \$DIS"
--- /dev/null
+++ b/opt/setup/README.md
@@ -1,0 +1,41 @@
+# Description
+
+Scripts to setup projects installed in `/opt` (bind their commands, man
+pages, etc. to standard places).
+
+
+# Install
+
+Make directory with these scripts available in /opt/setup/.
+
+Install system-wide:
+
+```
+# git clone https://github.com/powerman/inferno-opt-setup.git $INFERNO_ROOT/opt/setup
+```
+
+or in your home directory:
+
+```
+$ git clone https://github.com/powerman/inferno-opt-setup.git $INFERNO_USER_HOME/opt/setup
+$ emu
+; bind opt /opt
+```
+
+
+# Usage
+
+Add this into `profile` file in your Inferno home dir:
+
+```
+/opt/setup/cmd
+/opt/setup/man
+```
+
+The `/opt/setup/cmd` will bind all commands provided by /opt packages into
+`/dis/`, to let you run these commands by their name, without long
+`/opt/provider/package/dis/cmd/` prefix.
+
+The `/opt/setup/man` will bind all man pages provided by /opt packages
+into `/man/*/` and union provided man indexes with `/man/*/INDEX`.
+
--- /dev/null
+++ b/opt/setup/cmd
@@ -1,0 +1,10 @@
+#!/dis/sh -n
+load std
+
+for d in /opt/*/dis/* /opt/*/*/dis/* {
+	or {ftest -d $d} {raise continue}
+	n := `{basename $d}
+	and {~ $n lib} {raise continue}
+	and {~ $n cmd} {n=''}
+	bind -b $d /dis/$n
+}
--- /dev/null
+++ b/opt/setup/man
@@ -1,0 +1,20 @@
+#!/dis/sh -n
+load std
+
+for d in /opt/*/man/* /opt/*/*/man/* {
+	or {ftest -d $d} {raise continue}
+	n := `{basename $d}
+	if {ftest -r $d/INDEX} {
+		f := '/chan/man-' ^ $n ^ '-INDEX'
+		or {ftest -w $f} {ramfile $f; cp /man/$n/INDEX $f}
+		echo -n "{cat $f $d/INDEX} > $f
+	}
+	bind -b $d /man/$n
+}
+
+for d in /man/[1-9]* {
+	n := `{basename $d}
+	f := '/chan/man-' ^ $n ^ '-INDEX'
+	or {ftest -r $f} {raise continue}
+	or {diff $f $d/INDEX >/dev/null} {bind $f $d/INDEX}
+}
--- /dev/null
+++ b/opt/skel/README.md
@@ -1,0 +1,90 @@
+# Description
+
+This project is example, which can be used as template to start new /opt
+project for OS Inferno.
+
+
+# Install
+
+Make directory with this app/module skeleton available in /opt/skel/.
+
+Install system-wide:
+
+```
+# git clone https://github.com/powerman/inferno-opt-skel.git $INFERNO_ROOT/opt/skel
+```
+
+or in your home directory:
+
+```
+$ git clone https://github.com/powerman/inferno-opt-skel.git $INFERNO_USER_HOME/opt/skel
+$ emu
+; bind opt /opt
+```
+
+## Dependencies
+
+* https://github.com/powerman/inferno-opt-mkfiles
+* https://github.com/powerman/inferno-contrib-tap (only for tests)
+* https://github.com/powerman/inferno-contrib-logger (example dependency for
+  example command :))
+* http://asciidoc.org/ (converter from asciidoc markup to other formats)
+* https://github.com/powerman/asciidoc-9man-backend (asciidoc 9man backend
+  for converting into Inferno man pages)
+
+Actually all these dependencies are optional:
+
+* mkfiles project can be just copied to ./mkfiles/ subdir in your project
+  to avoid dependency on external project
+* tap module needed only for testing; you can use another modules, but
+  this one is cool because it allow you to run tests using `prove` command
+  in host os (standard testing tool for Perl)
+* logger is just an example dependency, nothing more
+* asciidoc needed only if you like to generate Inferno man pages from
+  simple .txt source
+
+
+# Usage
+
+Just copy `/opt/skel/` into your project's directory when you start new
+project.
+
+You can build your project using these commands both from host os and
+inside emu (except `prove`, which works only in host os):
+
+```
+mk all
+mk install
+
+mk test
+prove -r
+
+mk clean
+mk nuke
+```
+
+## Example
+
+When this project installed in `/opt/skel` and your /opt is correctly set
+(https://github.com/powerman/inferno-opt-setup) you can also:
+
+```
+$ emu
+; examplecmd
+Hello from ExampleLib->init()
+user.warn: Dec  6 05:04:40 examplecmd[158]: Hello from ExampleCmd->init()
+user.err: Dec  6 05:04:40 examplecmd[158]: Hello from ExampleCmd->init()
+; man examplecmd
+EXAMPLECMD(1)                                       EXAMPLECMD(1)
+
+NAME
+     examplecmd - Example command in /opt skeleton project
+…
+; man examplelib
+EXAMPLELIB(2)                                       EXAMPLELIB(2)
+
+NAME
+     examplelib - Example library in /opt skeleton project
+…
+```
+
--- /dev/null
+++ b/opt/skel/appl/cmd/examplecmd.b
@@ -1,0 +1,65 @@
+implement ExampleCmd;
+
+include "sys.m";
+	sys: Sys;
+	sprint: import sys;
+include "draw.m";
+include "opt/powerman/logger/module/logger.m";
+	logger: Logger;
+	log, ERR, WARN, NOTICE, INFO, DEBUG: import logger;
+include "arg.m";
+include "opt/skel/module/examplelib.m";
+
+
+ExampleCmd: module
+{
+	init: fn(nil: ref Draw->Context, argv: list of string);
+};
+
+init(nil: ref Draw->Context, argv: list of string)
+{
+	sys		=  load Sys Sys->PATH;
+	logger		=  checkload(load Logger Logger->PATH, "Logger");
+	logger->init();
+	arg		:= checkload(load Arg Arg->PATH, "Arg");
+	arg->init(argv);
+	logger->progname(arg->progname());
+	examplelib	:= checkload(load ExampleLib ExampleLib->PATH, "ExampleLib");
+	examplelib->init();
+
+	arg->setusage(sprint("%s [-v]", arg->progname()));
+	while((p := arg->opt()) != 0)
+		case p {
+		'v' =>	logger->verbose++;
+		* =>	arg->usage();
+		}
+	argv = arg->argv();
+	if(len argv != 0)
+		arg->usage();
+
+	log(DEBUG,  "Hello from ExampleCmd->init()");
+	log(INFO,   "Hello from ExampleCmd->init()");
+	log(NOTICE, "Hello from ExampleCmd->init()");
+	log(WARN,   "Hello from ExampleCmd->init()");
+	log(ERR,    "Hello from ExampleCmd->init()");
+}
+
+
+###
+
+fail(s: string)
+{
+	if(logger != nil)
+		log(ERR, s);
+	else
+		sys->fprint(sys->fildes(2), "%s\n", s);
+	raise "fail:"+s;
+}
+
+checkload[T](x: T, s: string): T
+{
+	if(x == nil)
+		fail(sprint("load: %s: %r", s));
+	return x;
+}
+
--- /dev/null
+++ b/opt/skel/appl/cmd/mkfile
@@ -1,0 +1,27 @@
+PKGDIR=../..
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	t\
+
+<$MKFILES/mksubdirs
+
+
+DISBIN=$PKGDIR/dis/cmd
+
+TARG=\
+	examplecmd.dis\
+
+SYSMODULES=\
+	sys.m\
+	draw.m\
+	arg.m\
+
+OPTMODULES=\
+	opt/powerman/logger/module/logger.m\
+
+MODULES=\
+	$PKGDIR/module/examplelib.m\
+
+<$MKFILES/mkdis
--- /dev/null
+++ b/opt/skel/appl/cmd/t/mkfile
@@ -1,0 +1,21 @@
+PKGDIR=../../..
+<$PKGDIR/mkconfig
+
+
+TESTS=\
+	smoke.dis\
+
+TESTTARG=\
+
+SYSMODULES=\
+	sys.m\
+	draw.m\
+	sh.m\
+
+OPTMODULES=\
+	opt/powerman/tap/module/t.m\
+	opt/powerman/tap/module/tap.m\
+
+MODULES=\
+
+<$MKFILES/mktest
--- /dev/null
+++ b/opt/skel/appl/cmd/t/smoke.b
@@ -1,0 +1,13 @@
+implement T;
+
+include "opt/powerman/tap/module/t.m";
+include "sh.m";
+
+
+test()
+{
+	plan(1);
+
+	examplecmd := load Command "/opt/skel/dis/cmd/examplecmd.dis";
+	ok(examplecmd != nil, "examplecmd loaded as Command");
+}
--- /dev/null
+++ b/opt/skel/appl/cmd/t/smoke.t
@@ -1,0 +1,20 @@
+#!/bin/bash -i
+# This script designed to be executed from host os in any way:
+#	cd /…/project;	prove -r; mk test; appl/lib/t/smoke.t
+#	cd appl/lib;	prove -r; mk test; t/smoke.t
+#	cd t;		prove -r; mk test; ./smoke.t
+# It require PKGDIR, EMUPKGDIR and EMUCMD variables set in mkfile.
+
+# When this script executed not by mk (i.e. by prove or manually) it won't
+# have variables from mkfile in environment and will need to fetch them.
+function getvar() {
+	echo -e "<mkfile\ngetvar:VQ:\n\techo \$$1" |
+		mk -f /proc/self/fd/0 getvar
+}
+
+SUBDIR=$(pwd)
+cd $(getvar PKGDIR)
+PKGDIR=$(pwd)
+DIS=$(getvar EMUPKGDIR)${SUBDIR:${#PKGDIR}}/$(dirname $0)/$(basename $0 .t).dis
+
+eval "$(getvar EMUCMD) \$DIS"
--- /dev/null
+++ b/opt/skel/appl/lib/examplelib.b
@@ -1,0 +1,12 @@
+implement ExampleLib;
+
+include "sys.m";
+	sys: Sys;
+include "../../module/examplelib.m";
+
+
+init()
+{
+	sys = load Sys Sys->PATH;
+	sys->print("Hello from ExampleLib->init()\n");
+}
--- /dev/null
+++ b/opt/skel/appl/lib/mkfile
@@ -1,0 +1,24 @@
+PKGDIR=../..
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	t\
+
+<$MKFILES/mksubdirs
+
+
+DISBIN=$PKGDIR/dis/lib
+
+TARG=\
+	examplelib.dis\
+
+SYSMODULES=\
+	sys.m\
+
+OPTMODULES=\
+
+MODULES=\
+	$PKGDIR/module/examplelib.m\
+
+<$MKFILES/mkdis
--- /dev/null
+++ b/opt/skel/appl/lib/t/mkfile
@@ -1,0 +1,21 @@
+PKGDIR=../../..
+<$PKGDIR/mkconfig
+
+
+TESTS=\
+	smoke.dis\
+
+TESTTARG=\
+
+SYSMODULES=\
+	sys.m\
+	draw.m\
+
+OPTMODULES=\
+	opt/powerman/tap/module/t.m\
+	opt/powerman/tap/module/tap.m\
+
+MODULES=\
+	$PKGDIR/module/examplelib.m\
+
+<$MKFILES/mktest
--- /dev/null
+++ b/opt/skel/appl/lib/t/smoke.b
@@ -1,0 +1,18 @@
+implement T;
+
+include "opt/powerman/tap/module/t.m";
+include "../../../module/examplelib.m";
+	examplelib: ExampleLib;
+
+
+test()
+{
+	plan(1);
+
+	examplelib = load ExampleLib ExampleLib->PATH;
+	if(examplelib == nil)
+		bail_out(sprint("load %s: %r",ExampleLib->PATH));
+
+	{ examplelib->init(); } exception e { "*"=>catched(e); }
+	raised(nil, "init() doesn't raise");
+}
--- /dev/null
+++ b/opt/skel/appl/lib/t/smoke.t
@@ -1,0 +1,20 @@
+#!/bin/bash -i
+# This script designed to be executed from host os in any way:
+#	cd /…/project;	prove -r; mk test; appl/lib/t/smoke.t
+#	cd appl/lib;	prove -r; mk test; t/smoke.t
+#	cd t;		prove -r; mk test; ./smoke.t
+# It require PKGDIR, EMUPKGDIR and EMUCMD variables set in mkfile.
+
+# When this script executed not by mk (i.e. by prove or manually) it won't
+# have variables from mkfile in environment and will need to fetch them.
+function getvar() {
+	echo -e "<mkfile\ngetvar:VQ:\n\techo \$$1" |
+		mk -f /proc/self/fd/0 getvar
+}
+
+SUBDIR=$(pwd)
+cd $(getvar PKGDIR)
+PKGDIR=$(pwd)
+DIS=$(getvar EMUPKGDIR)${SUBDIR:${#PKGDIR}}/$(dirname $0)/$(basename $0 .t).dis
+
+eval "$(getvar EMUCMD) \$DIS"
--- /dev/null
+++ b/opt/skel/appl/mkfile
@@ -1,0 +1,9 @@
+PKGDIR=..
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	lib\
+	cmd\
+
+<$MKFILES/mksubdirs
binary files /dev/null b/opt/skel/dis/cmd/examplecmd.dis differ
binary files /dev/null b/opt/skel/dis/lib/examplelib.dis differ
--- /dev/null
+++ b/opt/skel/doc/1/examplecmd.man
@@ -1,0 +1,22 @@
+.TH EXAMPLECMD 1
+.SH NAME
+examplecmd \- Example command in /opt skeleton project
+.SH SYNOPSIS
+.EX
+examplecmd [-v]
+
+.EE
+.SH DESCRIPTION
+.PP
+This command is example how to implement commands in /opt project.
+.PP
+.B -v
+will increase log verbosity level.
+.SH SOURCE
+.PP
+.B /opt/skel/appl/cmd/examplecmd.b
+.br
+.SH SEE ALSO
+.PP
+.IR examplelib (2)
+.SH BUGS
--- /dev/null
+++ b/opt/skel/doc/1/examplecmd.txt
@@ -1,0 +1,34 @@
+EXAMPLECMD(1)
+=============
+
+== NAME
+
+examplecmd - Example command in /opt skeleton project
+
+
+== SYNOPSIS
+
+----
+examplecmd [-v]
+----
+
+
+== DESCRIPTION
+
+This command is example how to implement commands in /opt project.
+
+*-v* will increase log verbosity level.
+
+
+== SOURCE
+
+`/opt/skel/appl/cmd/examplecmd.b`
+
+
+== SEE ALSO
+
+examplelib(2)
+
+
+== BUGS
+
--- /dev/null
+++ b/opt/skel/doc/1/mkfile
@@ -1,0 +1,10 @@
+PKGDIR=../..
+<$PKGDIR/mkconfig
+
+
+MANDIR=$PKGDIR/man/1
+
+MANTARG=\
+	examplecmd\
+
+<$MKFILES/mkasciidoc
--- /dev/null
+++ b/opt/skel/doc/2/examplelib.man
@@ -1,0 +1,26 @@
+.TH EXAMPLELIB 2
+.SH NAME
+examplelib \- Example library in /opt skeleton project
+.SH SYNOPSIS
+.EX
+include "opt/skel/module/examplelib.m";
+        examplelib: ExampleLib;
+examplelib = load ExampleLib ExampleLib->PATH;
+
+init: fn();
+
+.EE
+.SH DESCRIPTION
+.PP
+This module provide example how to implement library in /opt project.
+.PP
+.B init
+will say "hi" to you.
+.SH SOURCE
+.PP
+.B /opt/skel/appl/lib/examplelib.b
+.br
+.SH SEE ALSO
+.PP
+.IR examplecmd (1)
+.SH BUGS
--- /dev/null
+++ b/opt/skel/doc/2/examplelib.txt
@@ -1,0 +1,38 @@
+EXAMPLELIB(2)
+=============
+
+== NAME
+
+examplelib - Example library in /opt skeleton project
+
+
+== SYNOPSIS
+
+----
+include "opt/skel/module/examplelib.m";
+	examplelib: ExampleLib;
+examplelib = load ExampleLib ExampleLib->PATH;
+
+init: fn();
+----
+
+
+== DESCRIPTION
+
+This module provide example how to implement library in /opt project.
+
+*init* will say "hi" to you.
+
+
+== SOURCE
+
+`/opt/skel/appl/lib/examplelib.b`
+
+
+== SEE ALSO
+
+examplecmd(1)
+
+
+== BUGS
+
--- /dev/null
+++ b/opt/skel/doc/2/mkfile
@@ -1,0 +1,10 @@
+PKGDIR=../..
+<$PKGDIR/mkconfig
+
+
+MANDIR=$PKGDIR/man/2
+
+MANTARG=\
+	examplelib\
+
+<$MKFILES/mkasciidoc
--- /dev/null
+++ b/opt/skel/doc/mkfile
@@ -1,0 +1,9 @@
+PKGDIR=..
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	1\
+	2\
+
+<$MKFILES/mksubdirs
--- /dev/null
+++ b/opt/skel/man/1/INDEX
@@ -1,0 +1,1 @@
+examplecmd examplecmd
--- /dev/null
+++ b/opt/skel/man/1/examplecmd
@@ -1,0 +1,22 @@
+.TH EXAMPLECMD 1
+.SH NAME
+examplecmd \- Example command in /opt skeleton project
+.SH SYNOPSIS
+.EX
+examplecmd [-v]
+
+.EE
+.SH DESCRIPTION
+.PP
+This command is example how to implement commands in /opt project.
+.PP
+.B -v
+will increase log verbosity level.
+.SH SOURCE
+.PP
+.B /opt/skel/appl/cmd/examplecmd.b
+.br
+.SH SEE ALSO
+.PP
+.IR examplelib (2)
+.SH BUGS
--- /dev/null
+++ b/opt/skel/man/2/INDEX
@@ -1,0 +1,1 @@
+examplelib examplelib
--- /dev/null
+++ b/opt/skel/man/2/examplelib
@@ -1,0 +1,26 @@
+.TH EXAMPLELIB 2
+.SH NAME
+examplelib \- Example library in /opt skeleton project
+.SH SYNOPSIS
+.EX
+include "opt/skel/module/examplelib.m";
+        examplelib: ExampleLib;
+examplelib = load ExampleLib ExampleLib->PATH;
+
+init: fn();
+
+.EE
+.SH DESCRIPTION
+.PP
+This module provide example how to implement library in /opt project.
+.PP
+.B init
+will say "hi" to you.
+.SH SOURCE
+.PP
+.B /opt/skel/appl/lib/examplelib.b
+.br
+.SH SEE ALSO
+.PP
+.IR examplecmd (1)
+.SH BUGS
--- /dev/null
+++ b/opt/skel/man/mkfile
@@ -1,0 +1,9 @@
+PKGDIR=..
+<$PKGDIR/mkconfig
+
+
+MANDIRS=\
+	1\
+	2\
+
+<$MKFILES/mkindices
--- /dev/null
+++ b/opt/skel/mkconfig
@@ -1,0 +1,26 @@
+<$ROOT/mkconfig
+
+
+# PKGDIR: [host,emu] path to project's root (from mkfile's dir).
+# Used to run tests. Also very useful to simplify paths in any mkfile.
+PKGDIR=$PKGDIR	# MUST BE SET IN EVERY mkfile BEFORE INCLUDING THIS mkconfig!
+
+# OPTDIR: [host,emu] path to dir with opt/ subdir (from mkfile's dir).
+# Used to find modules by relative path (e.g. opt/powerman/tap/module/t.m).
+OPTDIR=${OSTARG:Inferno=/}
+OPTDIR=${OPTDIR:os=$INFERNO_HOME}
+
+# MKFILES: [host,emu] path to mkfiles/ dir (from mkfile's dir).
+# Used to find helper files needed by some mkfiles and ease including them.
+MKFILES=$OPTDIR/opt/mkfiles
+
+# EMUCMD: command to run .dis file from host os.
+# EMUPKGDIR: [emu] path to project's root (from $EMUCMD's dir).
+# Used to run tests from host os (e.g. $EMUCMD $EMUPKGDIR/appl/lib/t/smoke.dis).
+EMUCMD='emu-g sh -c "run /lib/sh/profile; \$1; shutdown -h"'
+EMUPKGDIR=/opt/skel
+
+
+# Default target (first target in first loaded mkfile).
+usage:QV:
+    echo mk all, install, test, clean or nuke
--- /dev/null
+++ b/opt/skel/mkfile
@@ -1,0 +1,10 @@
+PKGDIR=.
+<$PKGDIR/mkconfig
+
+
+DIRS=\
+	appl\
+	doc\
+	man\
+
+<$MKFILES/mksubdirs
--- /dev/null
+++ b/opt/skel/module/examplelib.m
@@ -1,0 +1,6 @@
+ExampleLib: module
+{
+	PATH: con "/opt/skel/dis/lib/examplelib.dis";
+
+	init: fn();
+};
--- /dev/null
+++ b/usr/inferno/lib/plumbing
@@ -1,0 +1,60 @@
+# these are in order from most specific to least,
+# since first rule that fires wins.
+
+# image files go to wm/view
+kind is text
+data matches '[a-zA-Z0-9_\-./]+'
+data matches '([a-zA-Z0-9_\-./]+)\.(jpg|jpeg|gif|bit|png)'
+data isfile     $0
+plumb to view
+plumb start /dis/wm/view.dis -i $file
+
+# sounds go to auplay
+kind is text
+data matches '[a-zA-Z0-9_\-./]+'
+data matches '([a-zA-Z0-9_\-./]+)\.(iaf|wav)'
+data isfile     $0
+plumb alwaysstart auplay
+plumb start /dis/auplay.dis $file
+
+# URLs go to wm/charon
+kind is text
+data matches '(https?|ftp|file|gopher|mailto|news|nntp|telnet|wais|prospero)://[a-zA-Z0-9_@]+([.:][a-zA-Z0-9_@]+)*/?[a-zA-Z0-9_?#~&/\-]+([:.][a-zA-Z0-9_?#~&/\-]+)*'
+plumb to web
+plumb start /dis/charon.dis $0
+
+# file URLs go to wm/charon
+kind is text
+data matches '[a-zA-Z0-9_/\-]+\.html?'
+data isfile $0
+data set file://localhost$file
+plumb to web
+plumb start /dis/charon.dis $data
+
+# .m files are looked up in /module and passed to wm/brutus
+kind is text
+data matches '([a-zA-Z0-9]+\.m)(:[0-9]+)?'
+data isfile     /module/$1
+data set        /module/$0
+plumb to edit
+plumb start /dis/wm/brutus.dis $file$2
+
+# existing files, possibly tagged by line number, go to wm/brutus
+kind is text
+data matches '([.a-zA-Z0-9_/\-]+[a-zA-Z0-9_/\-])(:[0-9]+)?'
+data isfile     $1
+plumb to edit
+plumb start /dis/wm/brutus.dis $file$2
+
+# existing files go to brutus
+kind is text
+data matches '[a-zA-Z0-9_./\-]+'
+data isdir      $0
+plumb alwaysstart dir # nasty plumbing hack
+plumb start /dis/wm/dir.dis $dir
+
+# man pages
+kind is text
+data matches '([a-zA-Z\-]+)\(([0-9]+)\)'
+plumb alwaysstart man # nasty plumbing hack
+plumb start /dis/wm/man.dis $2 $1
--- /dev/null
+++ b/usr/inferno/lib/profile
@@ -1,0 +1,10 @@
+# Personal sh intialisation
+
+# Networking
+ndb/cs
+ndb/dns
+
+# /opt package setup
+/opt/setup/cmd
+/opt/setup/man
+
--- /dev/null
+++ b/usr/inferno/namespace
@@ -1,0 +1,1 @@
+bind -ia #C /
binary files a/utils/mk/mk b/utils/mk/mk differ