Import sources from 2011-03-30 iso image

552 files changed, 37283 insertions, 0 deletions

diff --git a/sys/src/ape/lib/9/386/getcallerpc.s b/sys/src/ape/lib/9/386/getcallerpc.s
new file mode 100755
index 000000000..bc4a5f1ea
--- /dev/null
+++ b/sys/src/ape/lib/9/386/getcallerpc.s
@@ -0,0 +1,4 @@
+TEXT getcallerpc(SB), $0
+	MOVL	v+0(FP), AX
+	MOVL	-4(AX), AX
+	RET
diff --git a/sys/src/ape/lib/9/386/getfcr.s b/sys/src/ape/lib/9/386/getfcr.s
new file mode 100755
index 000000000..3ca21129d
--- /dev/null
+++ b/sys/src/ape/lib/9/386/getfcr.s
@@ -0,0 +1,27 @@
+
+TEXT	setfcr(SB), $0
+	MOVL	p+0(FP),AX
+	XORB	$0x3f,AX
+	PUSHW	AX
+	WAIT
+	FLDCW	0(SP)
+	POPW	AX
+	RET
+
+TEXT	getfcr(SB), $0
+	PUSHW	AX
+	WAIT
+	FSTCW	0(SP)
+	POPW	AX
+	XORB	$0x3f,AX
+	RET
+
+TEXT	getfsr(SB), $0
+	WAIT
+	FSTSW	AX
+	RET
+
+TEXT	setfsr(SB), $0
+	WAIT
+	FCLEX
+	RET
diff --git a/sys/src/ape/lib/9/68020/getcallerpc.s b/sys/src/ape/lib/9/68020/getcallerpc.s
new file mode 100755
index 000000000..78f2f9db9
--- /dev/null
+++ b/sys/src/ape/lib/9/68020/getcallerpc.s
@@ -0,0 +1,3 @@
+TEXT getcallerpc(SB), $0
+	MOVL	(a+0(FP)), R0
+	RTS
diff --git a/sys/src/ape/lib/9/68020/getfcr.s b/sys/src/ape/lib/9/68020/getfcr.s
new file mode 100755
index 000000000..7f67d038f
--- /dev/null
+++ b/sys/src/ape/lib/9/68020/getfcr.s
@@ -0,0 +1,19 @@
+TEXT	getfsr(SB), $0
+	MOVL	$0, R0
+	MOVL	FPSR, R0
+	RTS
+
+TEXT	setfsr(SB), $0
+	MOVL	new+0(FP), R1
+	MOVL	R1, FPSR
+	RTS
+
+TEXT	getfcr(SB), $0
+	MOVL	$0, R0
+	MOVL	FPCR, R0
+	RTS
+
+TEXT	setfcr(SB), $0
+	MOVL	new+0(FP), R1
+	MOVL	R1, FPCR
+	RTS
diff --git a/sys/src/ape/lib/9/alpha/getcallerpc.s b/sys/src/ape/lib/9/alpha/getcallerpc.s
new file mode 100755
index 000000000..2214561be
--- /dev/null
+++ b/sys/src/ape/lib/9/alpha/getcallerpc.s
@@ -0,0 +1,4 @@
+TEXT	getcallerpc(SB), $-8
+	MOVL	0(SP), R0
+	RET
+
diff --git a/sys/src/ape/lib/9/alpha/getfcr.s b/sys/src/ape/lib/9/alpha/getfcr.s
new file mode 100755
index 000000000..06df5de98
--- /dev/null
+++ b/sys/src/ape/lib/9/alpha/getfcr.s
@@ -0,0 +1,57 @@
+#define	EXCB	WORD	$0x60000400		/* until 7a/7l catch up */
+
+TEXT	getfsr(SB), $8
+	EXCB
+	MOVT	FPCR, F0
+	EXCB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R1
+	MOVQ	$0x01e00000, R2
+	AND		R2, R1, R0
+	RET
+
+TEXT	setfsr(SB), $8
+	MOVQ	$0x01e00000, R2
+	EXCB
+	MOVT	FPCR, F0
+	EXCB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R1
+	ANDNOT	R2, R1, R3
+	AND		R2, R0, R4
+	OR		R3, R4, R5
+	MOVL	R5, tmp-4(SP)
+	MOVT	tmp-8(SP), F0
+	EXCB
+	MOVT	F0, FPCR
+	EXCB
+	RET
+
+TEXT	getfcr(SB), $8
+	EXCB
+	MOVT	FPCR, F0
+	EXCB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R1
+	MOVQ	$0x700c0000, R2
+	AND		R2, R1, R0
+	XOR		R2, R0
+	RET
+
+TEXT	setfcr(SB), $8
+	MOVQ	$0x700c0000, R2
+	XOR		R2, R0
+	EXCB
+	MOVT	FPCR, F0
+	EXCB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R1
+	ANDNOT	R2, R1, R3
+	AND		R2, R0, R4
+	OR		R3, R4, R5
+	MOVL	R5, tmp-4(SP)
+	MOVT	tmp-8(SP), F0
+	EXCB
+	MOVT	F0, FPCR
+	EXCB
+	RET
diff --git a/sys/src/ape/lib/9/arm/getcallerpc.s b/sys/src/ape/lib/9/arm/getcallerpc.s
new file mode 100755
index 000000000..ac4575913
--- /dev/null
+++ b/sys/src/ape/lib/9/arm/getcallerpc.s
@@ -0,0 +1,3 @@
+TEXT getcallerpc(SB), $-4
+	MOVW	0(R13), R0
+	RET
diff --git a/sys/src/ape/lib/9/arm/getfcr.s b/sys/src/ape/lib/9/arm/getfcr.s
new file mode 100755
index 000000000..b27c7f082
--- /dev/null
+++ b/sys/src/ape/lib/9/arm/getfcr.s
@@ -0,0 +1,16 @@
+
+TEXT	setfcr(SB), $4
+	MOVW	R0, FPCR
+	RET
+
+TEXT	getfcr(SB), $4
+	MOVW	FPCR, R0
+	RET
+
+TEXT	getfsr(SB), $0
+	MOVW	FPSR, R0
+	RET
+
+TEXT	setfsr(SB), $0
+	MOVW	R0, FPSR
+	RET
diff --git a/sys/src/ape/lib/9/bind.c b/sys/src/ape/lib/9/bind.c
new file mode 100755
index 000000000..ef9c2db8c
--- /dev/null
+++ b/sys/src/ape/lib/9/bind.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_BIND(char*, char*, int);
+
+int
+bind(char *name, char *old, int flag)
+{
+	return _BIND(name, old, flag);
+}
diff --git a/sys/src/ape/lib/9/errstr.c b/sys/src/ape/lib/9/errstr.c
new file mode 100755
index 000000000..d790b85f2
--- /dev/null
+++ b/sys/src/ape/lib/9/errstr.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_ERRSTR(char*, unsigned int);
+
+int
+errstr(char *err, unsigned int nerr)
+{
+	return _ERRSTR(err, nerr);
+}
diff --git a/sys/src/ape/lib/9/mips/getcallerpc.s b/sys/src/ape/lib/9/mips/getcallerpc.s
new file mode 100755
index 000000000..7397526e7
--- /dev/null
+++ b/sys/src/ape/lib/9/mips/getcallerpc.s
@@ -0,0 +1,4 @@
+TEXT	getcallerpc(SB), $0
+	MOVW	0(SP), R1
+	RET
+
diff --git a/sys/src/ape/lib/9/mips/getfcr.s b/sys/src/ape/lib/9/mips/getfcr.s
new file mode 100755
index 000000000..9e84cbccd
--- /dev/null
+++ b/sys/src/ape/lib/9/mips/getfcr.s
@@ -0,0 +1,15 @@
+TEXT	getfsr(SB), $0
+	MOVW	FCR31, R1
+	RET
+
+TEXT	setfsr(SB), $0
+	MOVW	R1, FCR31
+	RET
+
+TEXT	getfcr(SB), $0
+	MOVW	FCR31, R1
+	RET
+
+TEXT	setfcr(SB), $0
+	MOVW	R1, FCR31
+	RET
diff --git a/sys/src/ape/lib/9/mkfile b/sys/src/ape/lib/9/mkfile
new file mode 100755
index 000000000..1715e62f8
--- /dev/null
+++ b/sys/src/ape/lib/9/mkfile
@@ -0,0 +1,27 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/lib9.a
+OFILES=errstr.$O\
+	bind.$O\
+	getcallerpc.$O\
+	getfcr.$O\
+	mount.$O\
+	rendezvous.$O\
+	rfork.$O\
+	segattach.$O\
+	segdetach.$O\
+	segflush.$O\
+	segfree.$O\
+	setmalloctag.$O\
+	unmount.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c $CFLAGS -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
+%.$O:	$objtype/%.s
+	$AS $prereq
+
+%.$O:	$objtype/%.c
+	$CC $CFLAGS $prereq
diff --git a/sys/src/ape/lib/9/mount.c b/sys/src/ape/lib/9/mount.c
new file mode 100755
index 000000000..667b4c9a6
--- /dev/null
+++ b/sys/src/ape/lib/9/mount.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_MOUNT(int, int, char*, int, char*);
+
+int
+mount(int fd, int afd, char *old, int flag, char *aname)
+{
+	return _MOUNT(fd, afd, old, flag, aname);
+}
diff --git a/sys/src/ape/lib/9/power/getcallerpc.s b/sys/src/ape/lib/9/power/getcallerpc.s
new file mode 100755
index 000000000..b031670e2
--- /dev/null
+++ b/sys/src/ape/lib/9/power/getcallerpc.s
@@ -0,0 +1,4 @@
+TEXT	getcallerpc(SB), $-4
+	MOVW	0(R1), R3
+	RETURN
+
diff --git a/sys/src/ape/lib/9/power/getfcr.s b/sys/src/ape/lib/9/power/getfcr.s
new file mode 100755
index 000000000..b61d52e68
--- /dev/null
+++ b/sys/src/ape/lib/9/power/getfcr.s
@@ -0,0 +1,28 @@
+TEXT	getfcr(SB), $8
+	MOVFL	FPSCR, F3
+	FMOVD	F3, f-8(SP)
+	MOVW	-4(SP), R3
+	RETURN
+
+TEXT	getfsr(SB), $8
+	MOVFL	FPSCR, F3
+	FMOVD	F3, f-8(SP)
+	MOVW	-4(SP), R3
+	RETURN
+
+TEXT	setfcr(SB), $8
+	SYNC
+	MOVW	R3, -4(SP)
+	FMOVD	-8(SP), F3
+	MOVFL	F3, FPSCR
+	ISYNC
+	RETURN
+
+TEXT	setfsr(SB), $8
+	SYNC
+	MOVW	R3, -4(SP)
+	FMOVD	-8(SP), F3
+	MOVFL	F3, FPSCR
+	ISYNC
+	RETURN
+
diff --git a/sys/src/ape/lib/9/rendezvous.c b/sys/src/ape/lib/9/rendezvous.c
new file mode 100755
index 000000000..0e184c2f6
--- /dev/null
+++ b/sys/src/ape/lib/9/rendezvous.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	unsigned long	_RENDEZVOUS(unsigned long, unsigned long);
+
+unsigned long
+rendezvous(unsigned long tag, unsigned long value)
+{
+	return _RENDEZVOUS(tag, value);
+}
diff --git a/sys/src/ape/lib/9/rfork.c b/sys/src/ape/lib/9/rfork.c
new file mode 100755
index 000000000..759739bdf
--- /dev/null
+++ b/sys/src/ape/lib/9/rfork.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_RFORK(int);
+
+int
+rfork(int flags)
+{
+	return _RFORK(flags);
+}
diff --git a/sys/src/ape/lib/9/segattach.c b/sys/src/ape/lib/9/segattach.c
new file mode 100755
index 000000000..f99f4877d
--- /dev/null
+++ b/sys/src/ape/lib/9/segattach.c
@@ -0,0 +1,10 @@
+#include <lib9.h>
+
+extern	int	_SEGATTACH(int, char*, void*, unsigned long);
+
+int
+segattach(int attr, char *class, void *va, unsigned long len)
+{
+	return _SEGATTACH(attr, class, va, len);
+}
+
diff --git a/sys/src/ape/lib/9/segbrk.c b/sys/src/ape/lib/9/segbrk.c
new file mode 100755
index 000000000..9e8d10eae
--- /dev/null
+++ b/sys/src/ape/lib/9/segbrk.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern int	_SEGBRK(void*, void*);
+
+int
+segbrk(void *saddr, void *addr)
+{
+	return _SEGBRK(saddr, addr);
+}
diff --git a/sys/src/ape/lib/9/segdetach.c b/sys/src/ape/lib/9/segdetach.c
new file mode 100755
index 000000000..88596fd04
--- /dev/null
+++ b/sys/src/ape/lib/9/segdetach.c
@@ -0,0 +1,10 @@
+#include <lib9.h>
+
+extern	int	_SEGDETACH(void *);
+
+int
+segdetach(void *addr)
+{
+	return _SEGDETACH(addr);
+}
+
diff --git a/sys/src/ape/lib/9/segflush.c b/sys/src/ape/lib/9/segflush.c
new file mode 100755
index 000000000..44259e689
--- /dev/null
+++ b/sys/src/ape/lib/9/segflush.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_SEGFLUSH(void*, unsigned long);
+
+int
+segflush(void *va, unsigned long len)
+{
+	return _SEGFLUSH(va, len);
+}
diff --git a/sys/src/ape/lib/9/segfree.c b/sys/src/ape/lib/9/segfree.c
new file mode 100755
index 000000000..06b3fbbde
--- /dev/null
+++ b/sys/src/ape/lib/9/segfree.c
@@ -0,0 +1,10 @@
+#include <lib9.h>
+
+extern	int	_SEGFREE(void*, unsigned long);
+
+int
+segfree(void *va, unsigned long len)
+{
+	return _SEGFREE(va, len);
+}
+
diff --git a/sys/src/ape/lib/9/setmalloctag.c b/sys/src/ape/lib/9/setmalloctag.c
new file mode 100755
index 000000000..b5d159475
--- /dev/null
+++ b/sys/src/ape/lib/9/setmalloctag.c
@@ -0,0 +1,4 @@
+void
+setmalloctag(void*, unsigned long)
+{
+}
diff --git a/sys/src/ape/lib/9/sparc/getcallerpc.s b/sys/src/ape/lib/9/sparc/getcallerpc.s
new file mode 100755
index 000000000..05d70f118
--- /dev/null
+++ b/sys/src/ape/lib/9/sparc/getcallerpc.s
@@ -0,0 +1,3 @@
+TEXT getcallerpc(SB), $0
+	MOVW	0(R1), R7
+	RETURN
diff --git a/sys/src/ape/lib/9/sparc/getfcr.s b/sys/src/ape/lib/9/sparc/getfcr.s
new file mode 100755
index 000000000..0059ada56
--- /dev/null
+++ b/sys/src/ape/lib/9/sparc/getfcr.s
@@ -0,0 +1,27 @@
+TEXT	getfsr(SB), $0
+	SUB	$4, R1
+	MOVW	FSR, (R1)
+	MOVW	(R1), R7
+	ADD	$4, R1
+	RETURN
+
+TEXT	setfsr(SB), $0
+	SUB	$4, R1
+	MOVW	R7, (R1)
+	MOVW	(R1), FSR
+	ADD	$4, R1
+	RETURN
+
+TEXT	setfcr(SB), $0
+	SUB	$4, R1
+	MOVW	R7, (R1)
+	MOVW	(R1), FSR
+	ADD	$4, R1
+	RETURN
+
+TEXT	getfcr(SB), $0
+	SUB	$4, R1
+	MOVW	FSR, (R1)
+	MOVW	(R1), R7
+	ADD	$4, R1
+	RETURN
diff --git a/sys/src/ape/lib/9/unmount.c b/sys/src/ape/lib/9/unmount.c
new file mode 100755
index 000000000..052f537d7
--- /dev/null
+++ b/sys/src/ape/lib/9/unmount.c
@@ -0,0 +1,9 @@
+#include <lib9.h>
+
+extern	int	_UNMOUNT(char*, char*);
+
+int
+unmount(char *name, char *old)
+{
+	return _UNMOUNT(name, old);
+}
diff --git a/sys/src/ape/lib/ap/386/cycles.s b/sys/src/ape/lib/ap/386/cycles.s
new file mode 100755
index 000000000..d1acbd2fc
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/cycles.s
@@ -0,0 +1,8 @@
+#define RDTSC 		BYTE $0x0F; BYTE $0x31
+
+TEXT _cycles(SB),1,$0		/* time stamp counter; cycles since power up */
+	RDTSC
+	MOVL	vlong+0(FP), CX	/* &vlong */
+	MOVL	AX, 0(CX)	/* lo */
+	MOVL	DX, 4(CX)	/* hi */
+	RET
diff --git a/sys/src/ape/lib/ap/386/lock.c b/sys/src/ape/lib/ap/386/lock.c
new file mode 100755
index 000000000..91c0ba233
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/lock.c
@@ -0,0 +1,26 @@
+#define _LOCK_EXTENSION
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	while(tas(&lk->val))
+		_SLEEP(0);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/386/main9.s b/sys/src/ape/lib/ap/386/main9.s
new file mode 100755
index 000000000..aef0777a4
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/main9.s
@@ -0,0 +1,13 @@
+	TEXT	_main(SB), 1, $12
+
+	CALL	_envsetup(SB)
+	MOVL	inargc-4(FP), AX
+	MOVL	AX, 0(SP)
+	LEAL	inargv+0(FP), AX
+	MOVL	AX, 4(SP)
+	MOVL	environ(SB), AX
+	MOVL	AX, 8(SP)
+	CALL	main(SB)
+	MOVL	AX, 0(SP)
+	CALL	exit(SB)
+	RET
diff --git a/sys/src/ape/lib/ap/386/main9p.s b/sys/src/ape/lib/ap/386/main9p.s
new file mode 100755
index 000000000..0ca3004a4
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/main9p.s
@@ -0,0 +1,46 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+
+	/* _tos = arg */
+	MOVL	AX, _tos(SB)
+	LEAL	8(SP), AX
+	MOVL	AX, _privates(SB)
+	MOVL	$NPRIVATES, _nprivates(SB)
+
+	/* _profmain(); */
+	CALL	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVL	_tos+0(SB),DX
+	MOVL	4(DX),CX
+	MOVL	CX,(DX)
+
+	CALL	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVL	inargc-4(FP), AX
+	MOVL	AX, 0(SP)
+	LEAL	inargv+0(FP), AX
+	MOVL	AX, 4(SP)
+	MOVL	environ(SB), AX
+	MOVL	AX, 8(SP)
+	CALL	main(SB)
+loop:
+	MOVL	AX, 0(SP)
+	CALL	exit(SB)
+	MOVL	$_profin(SB), AX	/* force loading of profile */
+	MOVL	$0, AX
+	JMP	loop
+
+TEXT	_savearg(SB), 1, $0
+	RET
+
+TEXT	_callpc(SB), 1, $0
+	MOVL	argp+0(FP), AX
+	MOVL	4(AX), AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/memchr.s b/sys/src/ape/lib/ap/386/memchr.s
new file mode 100755
index 000000000..23a1982a3
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/memchr.s
@@ -0,0 +1,23 @@
+	TEXT	memchr(SB),$0
+
+	MOVL	n+8(FP), CX
+	CMPL	CX, $0
+	JEQ	none
+	MOVL	p+0(FP), DI
+	MOVBLZX	c+4(FP), AX
+	CLD
+/*
+ * SCASB is memchr instruction
+ */
+
+	REPN;	SCASB
+	JEQ	found
+
+none:
+	MOVL	$0, AX
+	RET
+
+found:
+	MOVL	DI, AX
+	SUBL	$1, AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/memcmp.s b/sys/src/ape/lib/ap/386/memcmp.s
new file mode 100755
index 000000000..4e9d090cf
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/memcmp.s
@@ -0,0 +1,47 @@
+	TEXT	memcmp(SB),$0
+
+	MOVL	n+8(FP), BX
+	CMPL	BX, $0
+	JEQ	none
+	MOVL	p1+0(FP), DI
+	MOVL	p2+4(FP), SI
+	CLD
+/*
+ * first by longs
+ */
+
+	MOVL	BX, CX
+	SHRL	$2, CX
+
+	REP;	CMPSL
+	JNE	found
+
+/*
+ * then by bytes
+ */
+	ANDL	$3, BX
+	MOVL	BX, CX
+	REP;	CMPSB
+	JNE	found1
+
+none:
+	MOVL	$0, AX
+	RET
+
+/*
+ * if long found,
+ * back up and look by bytes
+ */
+found:
+	MOVL	$4, CX
+	SUBL	CX, DI
+	SUBL	CX, SI
+	REP;	CMPSB
+
+found1:
+	JLS	lt
+	MOVL	$-1, AX
+	RET
+lt:
+	MOVL	$1, AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/memcpy.s b/sys/src/ape/lib/ap/386/memcpy.s
new file mode 100755
index 000000000..bb9cfe40c
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/memcpy.s
@@ -0,0 +1,57 @@
+	TEXT	memcpy(SB), $0
+
+	MOVL	p1+0(FP), DI
+	MOVL	p2+4(FP), SI
+	MOVL	n+8(FP), BX
+	CMPL	BX, $0
+	JGE	ok
+	MOVL	$0, SI
+ok:
+	CLD
+/*
+ * check and set for backwards
+ */
+	CMPL	SI, DI
+	JLS	back
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ANDL	$3, BX
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p+0(FP),AX
+	RET
+/*
+ * whole thing backwards has
+ * adjusted addresses
+ */
+back:
+	ADDL	BX, DI
+	ADDL	BX, SI
+	SUBL	$4, DI
+	SUBL	$4, SI
+	STD
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	ANDL	$3, BX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ADDL	$3, DI
+	ADDL	$3, SI
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p+0(FP),AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/memmove.s b/sys/src/ape/lib/ap/386/memmove.s
new file mode 100755
index 000000000..45a72225f
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/memmove.s
@@ -0,0 +1,57 @@
+	TEXT	memmove(SB), $0
+
+	MOVL	p1+0(FP), DI
+	MOVL	p2+4(FP), SI
+	MOVL	n+8(FP), BX
+	CMPL	BX, $0
+	JGE	ok
+	MOVL	$0, SI
+ok:
+	CLD
+/*
+ * check and set for backwards
+ */
+	CMPL	SI, DI
+	JLS	back
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ANDL	$3, BX
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p+0(FP),AX
+	RET
+/*
+ * whole thing backwards has
+ * adjusted addresses
+ */
+back:
+	ADDL	BX, DI
+	ADDL	BX, SI
+	SUBL	$4, DI
+	SUBL	$4, SI
+	STD
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	ANDL	$3, BX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ADDL	$3, DI
+	ADDL	$3, SI
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p+0(FP),AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/memset.s b/sys/src/ape/lib/ap/386/memset.s
new file mode 100755
index 000000000..dacb2f5fb
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/memset.s
@@ -0,0 +1,35 @@
+	TEXT	memset(SB),$0
+
+	CLD
+	MOVL	p+0(FP), DI
+	MOVBLZX	c+4(FP), AX
+	MOVL	n+8(FP), BX
+/*
+ * if not enough bytes, just copy
+ */
+	CMPL	BX, $9
+	JLS	c3
+/*
+ * build word in AX
+ */
+	MOVB	AL, AH
+	MOVL	AX, CX
+	SHLL	$16, CX
+	ORL	CX, AX
+/*
+ * copy whole longs
+ */
+c1:
+	MOVL	BX, CX
+	SHRL	$2, CX
+	ANDL	$3, BX
+	REP;	STOSL
+/*
+ * copy the rest, by bytes
+ */
+c3:
+	MOVL	BX, CX
+	REP;	STOSB
+ret:
+	MOVL	p+0(FP),AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/mkfile b/sys/src/ape/lib/ap/386/mkfile
new file mode 100755
index 000000000..e19a4b852
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/mkfile
@@ -0,0 +1,27 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memchr.$O\
+	memcmp.$O\
+	memcpy.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strcat.$O\
+	strchr.$O\
+	strcpy.$O\
+	strlen.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/386/notetramp.c b/sys/src/ape/lib/ap/386/notetramp.c
new file mode 100755
index 000000000..19a6395f4
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->ax = ret;
+	if(ret == 0)
+		u->ax = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP] + 4;
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/386/setjmp.s b/sys/src/ape/lib/ap/386/setjmp.s
new file mode 100755
index 000000000..008a43f07
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/setjmp.s
@@ -0,0 +1,29 @@
+TEXT	longjmp(SB), $0
+	MOVL	r+4(FP), AX
+	CMPL	AX, $0
+	JNE	ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVL	$1, AX		/* bless their pointed heads */
+ok:	MOVL	l+0(FP), BX
+	MOVL	0(BX), SP	/* restore sp */
+	MOVL	4(BX), BX	/* put return pc on the stack */
+	MOVL	BX, 0(SP)
+	RET
+
+TEXT	setjmp(SB), $0
+	MOVL	l+0(FP), AX
+	MOVL	SP, 0(AX)	/* store sp */
+	MOVL	0(SP), BX	/* store return pc */
+	MOVL	BX, 4(AX)
+	MOVL	$0, AX		/* return 0 */
+	RET
+
+TEXT	sigsetjmp(SB), $0
+	MOVL	buf+0(FP), AX
+	MOVL	savemask+4(FP),BX
+	MOVL	BX,0(AX)
+	MOVL	$_psigblocked(SB),4(AX)
+	MOVL	SP, 8(AX)	/* store sp */
+	MOVL	0(SP), BX	/* store return pc */
+	MOVL	BX, 12(AX)
+	MOVL	$0, AX		/* return 0 */
+	RET
diff --git a/sys/src/ape/lib/ap/386/strcat.s b/sys/src/ape/lib/ap/386/strcat.s
new file mode 100755
index 000000000..3f41fefa5
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/strcat.s
@@ -0,0 +1,43 @@
+	TEXT	strcat(SB),$0
+
+	MOVL	$0, AX
+	MOVL	$-1, CX
+	CLD
+
+/*
+ * find length of second string
+ */
+
+	MOVL	p2+4(FP), DI
+	REPN;	SCASB
+
+	MOVL	DI, BX
+	SUBL	p2+4(FP), BX
+
+/*
+ * find end of first string
+ */
+
+	MOVL	p1+0(FP), DI
+	REPN;	SCASB
+
+/*
+ * copy the memory
+ */
+	SUBL	$1, DI
+	MOVL	p2+4(FP), SI
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ANDL	$3, BX
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p1+0(FP), AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/strchr.s b/sys/src/ape/lib/ap/386/strchr.s
new file mode 100755
index 000000000..873bdcf12
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/strchr.s
@@ -0,0 +1,38 @@
+	TEXT	strchr(SB), $0
+
+	MOVL	s+0(FP), DI
+	MOVB	c+4(FP), AX
+	CMPB	AX, $0
+	JEQ	l2	/**/
+
+/*
+ * char is not null
+ */
+l1:
+	MOVB	(DI), BX
+	CMPB	BX, $0
+	JEQ	ret0
+	ADDL	$1, DI
+	CMPB	AX, BX
+	JNE	l1
+
+	MOVL	DI, AX
+	SUBL	$1, AX
+	RET
+
+/*
+ * char is null
+ */
+l2:
+	MOVL	$-1, CX
+	CLD
+
+	REPN;	SCASB
+
+	MOVL	DI, AX
+	SUBL	$1, AX
+	RET
+
+ret0:
+	MOVL	$0, AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/strcpy.s b/sys/src/ape/lib/ap/386/strcpy.s
new file mode 100755
index 000000000..83482e8a2
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/strcpy.s
@@ -0,0 +1,35 @@
+	TEXT	strcpy(SB),$0
+
+	MOVL	$0, AX
+	MOVL	$-1, CX
+	CLD
+/*
+ * find end of second string
+ */
+
+	MOVL	p2+4(FP), DI
+	REPN;	SCASB
+
+	MOVL	DI, BX
+	SUBL	p2+4(FP), BX
+
+/*
+ * copy the memory
+ */
+	MOVL	p1+0(FP), DI
+	MOVL	p2+4(FP), SI
+/*
+ * copy whole longs
+ */
+	MOVL	BX, CX
+	SHRL	$2, CX
+	REP;	MOVSL
+/*
+ * copy the rest, by bytes
+ */
+	ANDL	$3, BX
+	MOVL	BX, CX
+	REP;	MOVSB
+
+	MOVL	p1+0(FP), AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/strlen.s b/sys/src/ape/lib/ap/386/strlen.s
new file mode 100755
index 000000000..e0330ffcc
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/strlen.s
@@ -0,0 +1,16 @@
+	TEXT	strlen(SB),$0
+
+	MOVL	$0, AX
+	MOVL	$-1, CX
+	CLD
+/*
+ * look for end of string
+ */
+
+	MOVL	p+0(FP), DI
+	REPN;	SCASB
+
+	MOVL	DI, AX
+	SUBL	p+0(FP), AX
+	SUBL	$1, AX
+	RET
diff --git a/sys/src/ape/lib/ap/386/tas.s b/sys/src/ape/lib/ap/386/tas.s
new file mode 100755
index 000000000..d756102db
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/tas.s
@@ -0,0 +1,6 @@
+TEXT	tas(SB),$0
+
+	MOVL	$0xdeadead,AX
+	MOVL	l+0(FP),BX
+	XCHGL	AX,(BX)
+	RET
diff --git a/sys/src/ape/lib/ap/386/vlop.s b/sys/src/ape/lib/ap/386/vlop.s
new file mode 100755
index 000000000..42e8a70df
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/vlop.s
@@ -0,0 +1,44 @@
+TEXT	_mulv(SB), $0
+	MOVL	r+0(FP), CX
+	MOVL	a+4(FP), AX
+	MULL	b+12(FP)
+	MOVL	AX, 0(CX)
+	MOVL	DX, BX
+	MOVL	a+4(FP), AX
+	MULL	b+16(FP)
+	ADDL	AX, BX
+	MOVL	a+8(FP), AX
+	MULL	b+12(FP)
+	ADDL	AX, BX
+	MOVL	BX, 4(CX)
+	RET
+
+TEXT	_mul64by32(SB), $0
+	MOVL	r+0(FP), CX
+	MOVL	a+4(FP), AX
+	MULL	b+12(FP)
+	MOVL	AX, 0(CX)
+	MOVL	DX, BX
+	MOVL	a+8(FP), AX
+	MULL	b+12(FP)
+	ADDL	AX, BX
+	MOVL	BX, 4(CX)
+	RET
+
+TEXT	_div64by32(SB), $0
+	MOVL	r+12(FP), CX
+	MOVL	a+0(FP), AX
+	MOVL	a+4(FP), DX
+	DIVL	b+8(FP)
+	MOVL	DX, 0(CX)
+	RET
+
+TEXT	_addv(SB), $0
+	MOVL	r+0(FP), CX
+	MOVL	a+4(FP), AX
+	MOVL	a+8(FP), BX
+	ADDL	b+12(FP), AX
+	ADCL	b+16(FP), BX
+	MOVL	AX, 0(CX)
+	MOVL	BX, 4(CX)
+	RET
diff --git a/sys/src/ape/lib/ap/386/vlrt.c b/sys/src/ape/lib/ap/386/vlrt.c
new file mode 100755
index 000000000..f0b100ef5
--- /dev/null
+++ b/sys/src/ape/lib/ap/386/vlrt.c
@@ -0,0 +1,695 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	union
+	{
+		struct
+		{
+			ulong	lo;
+			ulong	hi;
+		};
+		struct
+		{
+			ushort	lols;
+			ushort	loms;
+			ushort	hils;
+			ushort	hims;
+		};
+	};
+};
+
+void	abort(void);
+
+void
+_subv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo - b.lo;
+	hi = a.hi - b.hi;
+	if(lo > a.lo)
+		hi--;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; struct Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+ulong	_div64by32(Vlong, ulong, ulong*);
+void	_mul64by32(Vlong*, Vlong, ulong);
+
+static void
+dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
+{
+	ulong n;
+	Vlong x, q, r;
+
+	if(den.hi > num.hi || (den.hi == num.hi && den.lo > num.lo)){
+		if(qp) {
+			qp->hi = 0;
+			qp->lo = 0;
+		}
+		if(rp) {
+			rp->hi = num.hi;
+			rp->lo = num.lo;
+		}
+		return;
+	}
+
+	if(den.hi != 0){
+		q.hi = 0;
+		n = num.hi/den.hi;
+		_mul64by32(&x, den, n);
+		if(x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo)){
+			n--;
+			_mul64by32(&x, den, n);
+		}
+		q.lo = n;
+		_subv(&r, num, x);
+	} else {
+		if(num.hi >= den.lo){
+			q.hi = n = num.hi/den.lo;
+			num.hi -= den.lo*n;
+		} else {
+			q.hi = 0;
+		}
+		q.lo = _div64by32(num, den.lo, &r.lo);
+		r.hi = 0;
+	}
+	if(qp) {
+		qp->lo = q.lo;
+		qp->hi = q.hi;
+	}
+	if(rp) {
+		rp->lo = r.lo;
+		rp->hi = r.hi;
+	}
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	dodiv(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	dodiv(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_rshav(Vlong *r, Vlong a, int b)
+{
+	long t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = t>>31;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = t>>31;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_rshlv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = 0;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_lshv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.lo;
+	if(b >= 32) {
+		r->lo = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->hi = 0;
+			return;
+		}
+		r->hi = t << (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->lo = t;
+		r->hi = a.hi;
+		return;
+	}
+	r->lo = t << b;
+	r->hi = (t >> (32-b)) | (a.hi << b);
+}
+
+void
+_andv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi & b.hi;
+	r->lo = a.lo & b.lo;
+}
+
+void
+_orv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi | b.hi;
+	r->lo = a.lo | b.lo;
+}
+
+void
+_xorv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi ^ b.hi;
+	r->lo = a.lo ^ b.lo;
+}
+
+void
+_vpp(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+}
+
+void
+_vmm(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+}
+
+void
+_ppv(Vlong *l, Vlong *r)
+{
+
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_mmv(Vlong *l, Vlong *r)
+{
+
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u.lo = 0;
+	u.hi = 0;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
+
+void
+_p2v(Vlong *ret, void *p)
+{
+	long t;
+
+	t = (ulong)p;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sl2v(Vlong *ret, long sl)
+{
+	long t;
+
+	t = sl;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ul2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_si2v(Vlong *ret, int si)
+{
+	long t;
+
+	t = si;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ui2v(Vlong *ret, uint ui)
+{
+	long t;
+
+	t = ui;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sh2v(Vlong *ret, long sh)
+{
+	long t;
+
+	t = (sh << 16) >> 16;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uh2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xffff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sc2v(Vlong *ret, long uc)
+{
+	long t;
+
+	t = (uc << 24) >> 24;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uc2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+long
+_v2sc(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xff;
+	return (t << 24) >> 24;
+}
+
+long
+_v2uc(Vlong rv)
+{
+
+	return rv.lo & 0xff;
+}
+
+long
+_v2sh(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xffff;
+	return (t << 16) >> 16;
+}
+
+long
+_v2uh(Vlong rv)
+{
+
+	return rv.lo & 0xffff;
+}
+
+long
+_v2sl(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ul(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2si(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ui(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+int
+_testv(Vlong rv)
+{
+	return rv.lo || rv.hi;
+}
+
+int
+_eqv(Vlong lv, Vlong rv)
+{
+	return lv.lo == rv.lo && lv.hi == rv.hi;
+}
+
+int
+_nev(Vlong lv, Vlong rv)
+{
+	return lv.lo != rv.lo || lv.hi != rv.hi;
+}
+
+int
+_ltv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_gtv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_gev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
+
+int
+_lov(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lsv(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_hiv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_hsv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
diff --git a/sys/src/ape/lib/ap/68020/cycles.c b/sys/src/ape/lib/ap/68020/cycles.c
new file mode 100755
index 000000000..1c32bc732
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/cycles.c
@@ -0,0 +1,5 @@
+void
+_cycles(unsigned long long *u)
+{
+	*u = 0;
+}
diff --git a/sys/src/ape/lib/ap/68020/lock.c b/sys/src/ape/lib/ap/68020/lock.c
new file mode 100755
index 000000000..91c0ba233
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/lock.c
@@ -0,0 +1,26 @@
+#define _LOCK_EXTENSION
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	while(tas(&lk->val))
+		_SLEEP(0);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/68020/main9.s b/sys/src/ape/lib/ap/68020/main9.s
new file mode 100755
index 000000000..04e40c5e6
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/main9.s
@@ -0,0 +1,9 @@
+TEXT	_main(SB), 1, $16
+	MOVL	$a6base(SB), A6
+	PEA	inargv+0(FP)
+	MOVL	inargc-4(FP), TOS
+	BSR	_envsetup(SB)
+	BSR	main(SB)
+	MOVL	R0,TOS
+	BSR	exit(SB)
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/main9p.s b/sys/src/ape/lib/ap/68020/main9p.s
new file mode 100755
index 000000000..171355c5f
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/main9p.s
@@ -0,0 +1,43 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+	MOVL	$a6base(SB), A6
+
+	/* _tos = arg */
+	MOVL	R0, _tos(SB)		/* return value of sys exec!! */
+	LEA	private+8(SP), _privates(SB)
+	MOVL	$NPRIVATES, _nprivates(SB)
+
+	/* _profmain(); */
+	BSR	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVL	_tos+0(SB),A1
+	MOVL	4(A1),(A1)
+
+	BSR	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVL	environ(SB), TOS
+	PEA	inargv+0(FP)
+	MOVL	inargc-4(FP), TOS
+	BSR	main(SB)
+
+loop:
+	MOVL	R0,TOS
+	BSR	exit(SB)
+	LEA	_profin(SB), A0		/* force loading of profile */
+	BRA	loop
+
+
+TEXT	_savearg(SB), 1, $0
+	RTS
+
+TEXT	_callpc(SB), 1, $0
+	MOVL	argp+0(FP), A0
+	MOVL	4(A0), R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/memchr.s b/sys/src/ape/lib/ap/68020/memchr.s
new file mode 100755
index 000000000..ea2584df8
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/memchr.s
@@ -0,0 +1,15 @@
+	TEXT	memchr(SB),$0
+	MOVL	n+8(FP),R0
+	BEQ	ret
+	MOVL	s1+0(FP),A1
+	MOVL	c+4(FP),R1
+
+l1:	CMPB	R1,(A1)+
+	BEQ	eq
+	SUBL	$1,R0
+	BNE	l1
+	RTS
+
+eq:	MOVL	A1,R0
+	SUBL	$1,R0
+ret:	RTS
diff --git a/sys/src/ape/lib/ap/68020/memcmp.s b/sys/src/ape/lib/ap/68020/memcmp.s
new file mode 100755
index 000000000..97d208e3b
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/memcmp.s
@@ -0,0 +1,18 @@
+	TEXT	memcmp(SB),$0
+	MOVL	n+8(FP),R0
+	BEQ	ret
+	MOVL	s1+0(FP),A2
+	MOVL	s2+4(FP),A1
+
+l1:	CMPB	(A1)+,(A2)+
+	BNE	neq
+	SUBL	$1,R0
+	BNE	l1
+	RTS
+
+neq:	BCS	gtr
+	MOVL	$-1,R0
+	RTS
+
+gtr:	MOVL	$1,R0
+ret:	RTS
diff --git a/sys/src/ape/lib/ap/68020/memcpy.s b/sys/src/ape/lib/ap/68020/memcpy.s
new file mode 100755
index 000000000..2a37573da
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/memcpy.s
@@ -0,0 +1,98 @@
+	TEXT	memcpy(SB), $0
+
+	MOVL	n+8(FP),R0
+	BEQ	return
+	BGT	ok
+	MOVL	0, R0
+ok:
+	MOVL	s1+0(FP),A2
+	MOVL	s2+4(FP),A1
+
+	CMPL	A2,A1
+	BHI	back
+
+/*
+ * speed depends on source allignment
+ * destination allignment is secondary
+ * byte-at-a-time foreward copy to
+ * get source (A1) alligned.
+ */
+f1:
+	MOVL	A1, R1
+	ANDL	$3, R1
+	BEQ	f2
+	SUBL	$1, R0
+	BLT	return
+	MOVB	(A1)+, (A2)+
+	BRA	f1
+/*
+ * quad-long-at-a-time forward copy
+ */
+f2:
+	SUBL	$16, R0
+	BLT	f3
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	BRA	f2
+
+/*
+ * cleanup byte-at-a-time
+ */
+f3:
+	ADDL	$15, R0
+	BLT	return
+f4:
+	MOVB	(A1)+, (A2)+
+	SUBL	$1, R0
+	BGE	f4
+	BRA	return
+
+return:
+	MOVL	s1+0(FP),R0
+	RTS
+
+/*
+ * everything the same, but
+ * copy backwards
+ */
+back:
+	ADDL	R0, A1
+	ADDL	R0, A2
+
+/*
+ * byte-at-a-time backward copy to
+ * get source (A1) alligned.
+ */
+b1:
+	MOVL	A1, R1
+	ANDL	$3, R1
+	BEQ	b2
+	SUBL	$1, R0
+	BLT	return
+	MOVB	-(A1), -(A2)
+	BRA	b1
+/*
+ * quad-long-at-a-time backward copy
+ */
+b2:
+	SUBL	$16, R0
+	BLT	b3
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	BRA	b2
+
+/*
+ * cleanup byte-at-a-time backward
+ */
+b3:
+	ADDL	$15, R0
+	BLT	return
+b4:
+	MOVB	-(A1), -(A2)
+	SUBL	$1, R0
+	BGE	b4
+	BRA	return
diff --git a/sys/src/ape/lib/ap/68020/memmove.s b/sys/src/ape/lib/ap/68020/memmove.s
new file mode 100755
index 000000000..482b3d690
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/memmove.s
@@ -0,0 +1,99 @@
+	TEXT	memmove(SB), $0
+move:
+
+	MOVL	n+8(FP),R0
+	BEQ	return
+	BGT	ok
+	MOVL	0, R0
+ok:
+	MOVL	s1+0(FP),A2
+	MOVL	s2+4(FP),A1
+
+	CMPL	A2,A1
+	BHI	back
+
+/*
+ * speed depends on source allignment
+ * destination allignment is secondary
+ * byte-at-a-time foreward copy to
+ * get source (A1) alligned.
+ */
+f1:
+	MOVL	A1, R1
+	ANDL	$3, R1
+	BEQ	f2
+	SUBL	$1, R0
+	BLT	return
+	MOVB	(A1)+, (A2)+
+	BRA	f1
+/*
+ * quad-long-at-a-time forward copy
+ */
+f2:
+	SUBL	$16, R0
+	BLT	f3
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	MOVL	(A1)+, (A2)+
+	BRA	f2
+
+/*
+ * cleanup byte-at-a-time
+ */
+f3:
+	ADDL	$15, R0
+	BLT	return
+f4:
+	MOVB	(A1)+, (A2)+
+	SUBL	$1, R0
+	BGE	f4
+	BRA	return
+
+return:
+	MOVL	s1+0(FP),R0
+	RTS
+
+/*
+ * everything the same, but
+ * copy backwards
+ */
+back:
+	ADDL	R0, A1
+	ADDL	R0, A2
+
+/*
+ * byte-at-a-time backward copy to
+ * get source (A1) alligned.
+ */
+b1:
+	MOVL	A1, R1
+	ANDL	$3, R1
+	BEQ	b2
+	SUBL	$1, R0
+	BLT	return
+	MOVB	-(A1), -(A2)
+	BRA	b1
+/*
+ * quad-long-at-a-time backward copy
+ */
+b2:
+	SUBL	$16, R0
+	BLT	b3
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	MOVL	-(A1), -(A2)
+	BRA	b2
+
+/*
+ * cleanup byte-at-a-time backward
+ */
+b3:
+	ADDL	$15, R0
+	BLT	return
+b4:
+	MOVB	-(A1), -(A2)
+	SUBL	$1, R0
+	BGE	b4
+	BRA	return
diff --git a/sys/src/ape/lib/ap/68020/memset.s b/sys/src/ape/lib/ap/68020/memset.s
new file mode 100755
index 000000000..d4b773416
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/memset.s
@@ -0,0 +1,47 @@
+	TEXT	memset(SB), $0
+	MOVL	n+8(FP), R0
+	BLE	return
+	MOVL	s1+0(FP), A1
+	CLRL	R1
+	MOVB	c+7(FP), R1
+	BEQ	l1
+
+/*
+ * create 4 replicated copies
+ * of the byte in R1
+ */
+	MOVL	R1, R2
+	ASLL	$8, R2
+	ORL	R2, R1
+	MOVL	R1, R2
+	SWAP	R2
+	ORL	R2, R1
+
+/*
+ * quad-long-at-a-time set
+ * destination allignment is not
+ * very important.
+ */
+l1:
+	SUBL	$16, R0
+	BLT	l2
+	MOVL	R1, (A1)+
+	MOVL	R1, (A1)+
+	MOVL	R1, (A1)+
+	MOVL	R1, (A1)+
+	BRA	l1
+
+/*
+ * cleanup byte-at-a-time
+ */
+l2:
+	ADDL	$15, R0
+	BLT	return
+l3:
+	MOVB	R1, (A1)+
+	SUBL	$1, R0
+	BGE	l3
+
+return:
+	MOVL	s1+0(FP),R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/mkfile b/sys/src/ape/lib/ap/68020/mkfile
new file mode 100755
index 000000000..f71b3cef2
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/mkfile
@@ -0,0 +1,28 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memchr.$O\
+	memcmp.$O\
+	memcpy.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strcat.$O\
+	strchr.$O\
+	strcmp.$O\
+	strcpy.$O\
+	strlen.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/68020/notetramp.c b/sys/src/ape/lib/ap/68020/notetramp.c
new file mode 100755
index 000000000..7803a35c7
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r0 = ret;
+	if(ret == 0)
+		u->r0 = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP] + 4;
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/68020/setjmp.s b/sys/src/ape/lib/ap/68020/setjmp.s
new file mode 100755
index 000000000..c827376c2
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/setjmp.s
@@ -0,0 +1,26 @@
+TEXT	setjmp(SB), 1, $0
+	MOVL	b+0(FP), A0
+	MOVL	A7, (A0)+
+	MOVL	(A7), (A0)
+	CLRL	R0
+	RTS
+
+TEXT	sigsetjmp(SB), 1, $0
+	MOVL	b+0(FP), A0
+	MOVW	savemask+4(FP), R1
+	MOVW	R1, (A0)+
+	MOVW	$_psigblocked(SB), R1
+	MOVW	R1, (A0)+
+	MOVL	A7, (A0)+
+	MOVL	(A7), (A0)
+	CLRL	R0
+	RTS
+
+TEXT	longjmp(SB), 1, $0
+	MOVL	b+0(FP), A0
+	MOVL	r+4(FP), R0
+	BNE	ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVL	$1, R0		/* bless their pointed heads */
+ok:	MOVL	(A0)+, A7
+	MOVL	(A0), (A7)
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/strcat.s b/sys/src/ape/lib/ap/68020/strcat.s
new file mode 100755
index 000000000..95821408b
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/strcat.s
@@ -0,0 +1,15 @@
+	TEXT	strcat(SB), $0
+	MOVL	s1+0(FP), A2
+	MOVL	s2+4(FP), A1
+
+l1:	TSTB	(A2)+
+	BNE	l1
+
+	MOVB	(A1)+, -1(A2)
+	BEQ	done
+
+l2:	MOVB	(A1)+, (A2)+
+	BNE	l2
+
+done:	MOVL	s1+0(FP), R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/strchr.s b/sys/src/ape/lib/ap/68020/strchr.s
new file mode 100755
index 000000000..a5d4be2c6
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/strchr.s
@@ -0,0 +1,27 @@
+	TEXT	strchr(SB), $0
+
+	MOVL	s+0(FP), A0
+	MOVB	c+7(FP), R2
+	BEQ	null
+
+l:
+	MOVB	(A0)+, R1
+	BEQ	out
+	CMPB	R1, R2
+	BNE	l
+
+	MOVL	A0, R0
+	ADDL	$-1, R0
+	RTS
+
+out:
+	CLRL	R0
+	RTS
+
+null:
+	TSTB	(A0)+
+	BNE	null
+
+	MOVL	A0, R0
+	ADDL	$-1, R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/strcmp.s b/sys/src/ape/lib/ap/68020/strcmp.s
new file mode 100755
index 000000000..c6072efd7
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/strcmp.s
@@ -0,0 +1,20 @@
+	TEXT	strcmp(SB), $0
+	MOVL	s1+0(FP), A2
+	MOVL	s2+4(FP), A1
+
+l1:	MOVB	(A1)+, R0
+	BEQ	end
+	CMPB	R0, (A2)+
+	BEQ	l1
+
+	BCS	gtr
+	MOVL	$-1, R0
+	RTS
+
+gtr:	MOVL	$1, R0
+	RTS
+
+end:	TSTB	(A2)
+	BNE	gtr
+	CLRL	R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/strcpy.s b/sys/src/ape/lib/ap/68020/strcpy.s
new file mode 100755
index 000000000..ce5c30bdb
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/strcpy.s
@@ -0,0 +1,10 @@
+	TEXT	strcpy(SB), $0
+
+	MOVL	s1+0(FP), A2
+	MOVL	s2+4(FP), A1
+
+l1:	MOVB	(A1)+, (A2)+
+	BNE	l1
+
+	MOVL	s1+0(FP), R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/strlen.s b/sys/src/ape/lib/ap/68020/strlen.s
new file mode 100755
index 000000000..4d787c704
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/strlen.s
@@ -0,0 +1,18 @@
+	TEXT	strlen(SB), $0
+	MOVL	s+0(FP), A1
+
+	TSTB	(A1)+
+	BEQ	null
+	MOVL	A1, A2
+
+l1:
+	TSTB	(A1)+
+	BNE	l1
+
+	SUBL	A2, A1
+	MOVL	A1, R0
+	RTS
+
+null:
+	MOVL	$0, R0
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/tas.s b/sys/src/ape/lib/ap/68020/tas.s
new file mode 100755
index 000000000..ad5e7a9c9
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/tas.s
@@ -0,0 +1,9 @@
+TEXT	tas(SB), $0
+
+	MOVL	$0, R0
+	MOVL	a+0(FP), A0
+	TAS	(A0)
+	BEQ	tas_1
+	MOVL	$1, R0
+tas_1:
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/vlop.s b/sys/src/ape/lib/ap/68020/vlop.s
new file mode 100755
index 000000000..2f34fd645
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/vlop.s
@@ -0,0 +1,23 @@
+TEXT	_mulv(SB), $0
+	MOVL	r+0(FP), A0
+	MOVL	a+8(FP), R0
+
+	WORD	$0x4c2f
+	WORD	$0x0401
+	WORD	$0x0014
+/*
+ *	MULUL	b+16(FP), R0:R1
+ *	philw made me do it!
+ */
+
+	MOVL	a+4(FP), R2
+	MULUL	b+16(FP), R2
+	ADDL	R2, R1
+
+	MOVL	a+8(FP), R2
+	MULUL	b+12(FP), R2
+	ADDL	R2, R1
+
+	MOVL	R1, (A0)+
+	MOVL	R0, (A0)
+	RTS
diff --git a/sys/src/ape/lib/ap/68020/vlrt.c b/sys/src/ape/lib/ap/68020/vlrt.c
new file mode 100755
index 000000000..cfad2afc0
--- /dev/null
+++ b/sys/src/ape/lib/ap/68020/vlrt.c
@@ -0,0 +1,730 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	union
+	{
+		struct
+		{
+			ulong	hi;
+			ulong	lo;
+		};
+		struct
+		{
+			ushort	hims;
+			ushort	hils;
+			ushort	loms;
+			ushort	lols;
+		};
+	};
+};
+
+void	abort(void);
+
+void
+_addv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo + b.lo;
+	hi = a.hi + b.hi;
+	if(lo < a.lo)
+		hi++;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_subv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo - b.lo;
+	hi = a.hi - b.hi;
+	if(lo > a.lo)
+		hi--;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; struct Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+static void
+dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
+{
+	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
+	int i;
+
+	numhi = num.hi;
+	numlo = num.lo;
+	denhi = den.hi;
+	denlo = den.lo;
+
+	/*
+	 * get a divide by zero
+	 */
+	if(denlo==0 && denhi==0) {
+		numlo = numlo / denlo;
+	}
+
+	/*
+	 * set up the divisor and find the number of iterations needed
+	 */
+	if(numhi >= SIGN(32)) {
+		quohi = SIGN(32);
+		quolo = 0;
+	} else {
+		quohi = numhi;
+		quolo = numlo;
+	}
+	i = 0;
+	while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
+		denhi = (denhi<<1) | (denlo>>31);
+		denlo <<= 1;
+		i++;
+	}
+
+	quohi = 0;
+	quolo = 0;
+	for(; i >= 0; i--) {
+		quohi = (quohi<<1) | (quolo>>31);
+		quolo <<= 1;
+		if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
+			t = numlo;
+			numlo -= denlo;
+			if(numlo > t)
+				numhi--;
+			numhi -= denhi;
+			quolo |= 1;
+		}
+		denlo = (denlo>>1) | (denhi<<31);
+		denhi >>= 1;
+	}
+
+	if(q) {
+		q->lo = quolo;
+		q->hi = quohi;
+	}
+	if(r) {
+		r->lo = numlo;
+		r->hi = numhi;
+	}
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	dodiv(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	dodiv(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_rshav(Vlong *r, Vlong a, int b)
+{
+	long t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = t>>31;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = t>>31;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_rshlv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = 0;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_lshv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.lo;
+	if(b >= 32) {
+		r->lo = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->hi = 0;
+			return;
+		}
+		r->hi = t << (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->lo = t;
+		r->hi = a.hi;
+		return;
+	}
+	r->lo = t << b;
+	r->hi = (t >> (32-b)) | (a.hi << b);
+}
+
+void
+_andv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi & b.hi;
+	r->lo = a.lo & b.lo;
+}
+
+void
+_orv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi | b.hi;
+	r->lo = a.lo | b.lo;
+}
+
+void
+_xorv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi ^ b.hi;
+	r->lo = a.lo ^ b.lo;
+}
+
+void
+_negv(Vlong *r, Vlong a)
+{
+	if(a.lo == 0) {
+		r->hi = -a.hi;
+		r->lo = 0;
+		return;
+	}
+	r->hi = ~a.hi;
+	r->lo = -a.lo;
+}
+
+void
+_vpp(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+}
+
+void
+_vmm(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+}
+
+void
+_ppv(Vlong *l, Vlong *r)
+{
+
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_mmv(Vlong *l, Vlong *r)
+{
+
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u = *ret;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
+
+void
+_p2v(Vlong *ret, void *p)
+{
+	long t;
+
+	t = (ulong)p;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sl2v(Vlong *ret, long sl)
+{
+	long t;
+
+	t = sl;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ul2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_si2v(Vlong *ret, int si)
+{
+	long t;
+
+	t = si;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ui2v(Vlong *ret, uint ui)
+{
+	long t;
+
+	t = ui;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sh2v(Vlong *ret, long sh)
+{
+	long t;
+
+	t = (sh << 16) >> 16;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uh2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xffff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sc2v(Vlong *ret, long uc)
+{
+	long t;
+
+	t = (uc << 24) >> 24;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uc2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+long
+_v2sc(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xff;
+	return (t << 24) >> 24;
+}
+
+long
+_v2uc(Vlong rv)
+{
+
+	return rv.lo & 0xff;
+}
+
+long
+_v2sh(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xffff;
+	return (t << 16) >> 16;
+}
+
+long
+_v2uh(Vlong rv)
+{
+
+	return rv.lo & 0xffff;
+}
+
+long
+_v2sl(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ul(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2si(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ui(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+int
+_testv(Vlong rv)
+{
+	return rv.lo || rv.hi;
+}
+
+int
+_eqv(Vlong lv, Vlong rv)
+{
+	return lv.lo == rv.lo && lv.hi == rv.hi;
+}
+
+int
+_nev(Vlong lv, Vlong rv)
+{
+	return lv.lo != rv.lo || lv.hi != rv.hi;
+}
+
+int
+_ltv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_gtv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_gev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
+
+int
+_lov(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lsv(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_hiv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_hsv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
diff --git a/sys/src/ape/lib/ap/alpha/_seek.c b/sys/src/ape/lib/ap/alpha/_seek.c
new file mode 100755
index 000000000..7bccc0661
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/_seek.c
@@ -0,0 +1,12 @@
+extern	long	__SEEK(long long*, int, long long, int);
+
+long long
+_SEEK(int fd, long long o, int p)
+{
+	long long l;
+
+	if(__SEEK(&l, fd, o, p) < 0)
+		l = -1;
+	return l;
+}
+
diff --git a/sys/src/ape/lib/ap/alpha/cycles.c b/sys/src/ape/lib/ap/alpha/cycles.c
new file mode 100755
index 000000000..1c32bc732
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/cycles.c
@@ -0,0 +1,5 @@
+void
+_cycles(unsigned long long *u)
+{
+	*u = 0;
+}
diff --git a/sys/src/ape/lib/ap/alpha/divl.s b/sys/src/ape/lib/ap/alpha/divl.s
new file mode 100755
index 000000000..bce568a8e
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/divl.s
@@ -0,0 +1,189 @@
+/*
+ *	ulong
+ *	_udiv(ulong num, ulong den)
+ *	{
+ *		int i;
+ *		ulong quo;
+ *
+ *		if(den == 0)
+ *			*(ulong*)-1 = 0;
+ *		quo = num;
+ *		if(quo > 1<<(32-1))
+ *			quo = 1<<(32-1);
+ *		for(i=0; den<quo; i++)
+ *			den <<= 1;
+ *		quo = 0;
+ *		for(; i>=0; i--) {
+ *			quo <<= 1;
+ *			if(num >= den) {
+ *				num -= den;
+ *				quo |= 1;
+ *			}
+ *			den >>= 1;
+ *		}
+ *		return quo::num;
+ *	}
+ */
+
+#define	NOPROF	1
+
+/*
+ * calling sequence:
+ *	num: 8(R30)
+ *	den: 12(R30)
+ * returns
+ *	quo: 8(R30)
+ *	rem: 12(R30)
+ */
+TEXT	_udivmodl(SB), NOPROF, $-8
+
+	MOVQ	$-1, R11
+	SLLQ	$31, R11			/* (1<<31) in canonical form */
+	MOVL	8(R30), R23	/* numerator */
+	MOVL	12(R30), R10	/* denominator */
+	BNE	R10, udm20
+	MOVQ	R31, -1(R31)	/* fault -- divide by zero; todo: use gentrap? */
+udm20:
+	MOVQ	R23, R12
+	BGE	R12, udm34
+	MOVQ	R11, R12
+udm34:
+	MOVQ	R31, R11
+udm38:
+	CMPUGE	R10, R12, R24
+	BNE	R24, udm54
+	SLLL	$1, R10
+	ADDQ	$1, R11
+	JMP	udm38
+udm54:
+	MOVQ	R31, R12
+udm58:
+	BLT	R11, udm8c
+	SLLL		$1, R12
+	CMPUGE	R23, R10, R24
+	BEQ		R24, udm7c
+	SUBL		R10, R23
+	OR		$1, R12
+udm7c:
+	SRLL		$1, R10
+	SUBQ	$1, R11
+	JMP	udm58
+udm8c:
+	MOVL	R12, 8(R30)	/* quotient */
+	MOVL	R23, 12(R30)	/* remainder */
+	RET
+
+/*
+ * save working registers
+ * and bring in num/den parameters
+ */
+TEXT	_unsargl(SB), NOPROF, $-8
+	MOVQ	R10, 24(R30)
+	MOVQ	R11, 32(R30)
+	MOVQ	R12, 40(R30)
+	MOVQ	R23, 48(R30)
+	MOVQ	R24, 56(R30)
+
+	MOVL	R27, 8(R30)
+	MOVL	72(R30), R27
+	MOVL	R27, 12(R30)
+
+	RET
+
+/*
+ * save working registers
+ * and bring in absolute value
+ * of num/den parameters
+ */
+TEXT	_absargl(SB), NOPROF, $-8
+	MOVQ	R10, 24(R30)
+	MOVQ	R11, 32(R30)
+	MOVQ	R12, 40(R30)
+	MOVQ	R23, 48(R30)
+	MOVQ	R24, 56(R30)
+
+	MOVL	R27, 64(R30)
+	BGE	R27, ab1
+	SUBL	R27, R31, R27
+ab1:
+	MOVL	R27, 8(R30)	/* numerator */
+
+	MOVL	72(R30), R27
+	BGE	R27, ab2
+	SUBL	R27, R31, R27
+ab2:
+	MOVL	R27, 12(R30)	/* denominator */
+	RET
+
+/*
+ * restore registers and
+ * return to original caller
+ * answer is in R27
+ */
+TEXT	_retargl(SB), NOPROF, $-8
+	MOVQ	24(R30), R10
+	MOVQ	32(R30), R11
+	MOVQ	40(R30), R12
+	MOVQ	48(R30), R23
+	MOVQ	56(R30), R24
+	MOVL	0(R30), R26
+
+	ADDQ	$64, R30
+	RET			/* back to main sequence */
+
+TEXT	_divl(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVL	R26, 0(R30)
+
+	JSR	_absargl(SB)
+	JSR	_udivmodl(SB)
+	MOVL	8(R30), R27
+
+	MOVL	64(R30), R10	/* clean up the sign */
+	MOVL	72(R30), R11
+	XOR	R11, R10
+	BGE	R10, div1
+	SUBL	R27, R31, R27
+div1:
+
+	JSR	_retargl(SB)
+	RET			/* not executed */
+
+TEXT	_divlu(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVL	R26, 0(R30)
+
+	JSR	_unsargl(SB)
+	JSR	_udivmodl(SB)
+	MOVL	8(R30), R27
+
+	JSR	_retargl(SB)
+	RET			/* not executed */
+
+TEXT	_modl(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVL	R26, 0(R30)
+
+	JSR	_absargl(SB)
+	JSR	_udivmodl(SB)
+	MOVL	12(R30), R27
+
+	MOVL	64(R30), R10	/* clean up the sign */
+	BGE	R10, div2
+	SUBL	R27, R31, R27
+div2:
+
+	JSR	_retargl(SB)
+	RET			/* not executed */
+
+TEXT	_modlu(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVL	R26, 0(R30)
+
+	JSR	_unsargl(SB)
+	JSR	_udivmodl(SB)
+	MOVL	12(R30), R27
+
+	JSR	_retargl(SB)
+	RET			/* not executed */
+
diff --git a/sys/src/ape/lib/ap/alpha/divq.s b/sys/src/ape/lib/ap/alpha/divq.s
new file mode 100755
index 000000000..98a58e4a8
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/divq.s
@@ -0,0 +1,191 @@
+/*
+ *	uvlong
+ *	_udiv(uvlong num, uvlong den)
+ *	{
+ *		int i;
+ *		uvlong quo;
+ *
+ *		if(den == 0)
+ *			*(ulong*)-1 = 0;
+ *		quo = num;
+ *		if(quo > 1<<(64-1))
+ *			quo = 1<<(64-1);
+ *		for(i=0; den<quo; i++)
+ *			den <<= 1;
+ *		quo = 0;
+ *		for(; i>=0; i--) {
+ *			quo <<= 1;
+ *			if(num >= den) {
+ *				num -= den;
+ *				quo |= 1;
+ *			}
+ *			den >>= 1;
+ *		}
+ *		return quo::num;
+ *	}
+ */
+
+#define	NOPROF	1
+
+/*
+ * calling sequence:
+ *	num: 8(R30)
+ *	den: 16(R30)
+ * returns
+ *	quo: 8(R30)
+ *	rem: 16(R30)
+ */
+TEXT	_udivmodq(SB), NOPROF, $-8
+
+	MOVQ	$1, R11
+	SLLQ	$63, R11
+	MOVQ	8(R30), R23	/* numerator */
+	MOVQ	16(R30), R10	/* denominator */
+	BNE	R10, udm20
+	MOVQ	R31, -1(R31)	/* fault -- divide by zero; todo: use gentrap? */
+udm20:
+	MOVQ	R23, R12
+	BGE	R12, udm34
+	MOVQ	R11, R12
+udm34:
+	MOVQ	R31, R11
+udm38:
+	CMPUGE	R10, R12, R24
+	BNE	R24, udm54
+	SLLQ	$1, R10
+	ADDQ	$1, R11
+	JMP	udm38
+udm54:
+	MOVQ	R31, R12
+udm58:
+	BLT	R11, udm8c
+	SLLQ	$1, R12
+	CMPUGE	R23, R10, R24
+	BEQ	R24, udm7c
+	SUBQ	R10, R23
+	OR	$1, R12
+udm7c:
+	SRLQ	$1, R10
+	SUBQ	$1, R11
+	JMP	udm58
+udm8c:
+	MOVQ	R12, 8(R30)	/* quotient */
+	MOVQ	R23, 16(R30)	/* remainder */
+	RET
+
+/*
+ * save working registers
+ * and bring in num/den parameters
+ */
+TEXT	_unsargq(SB), NOPROF, $-8
+	MOVQ	R10, 24(R30)
+	MOVQ	R11, 32(R30)
+	MOVQ	R12, 40(R30)
+	MOVQ	R23, 48(R30)
+	MOVQ	R24, 56(R30)
+
+	MOVQ	R27, 8(R30)
+	MOVQ	72(R30), R27
+	MOVQ	R27, 16(R30)
+
+MOVQ	(R30), R10	/* debug */
+	RET
+
+/*
+ * save working registers
+ * and bring in absolute value
+ * of num/den parameters
+ */
+TEXT	_absargq(SB), NOPROF, $-8
+	MOVQ	R10, 24(R30)
+	MOVQ	R11, 32(R30)
+	MOVQ	R12, 40(R30)
+	MOVQ	R23, 48(R30)
+	MOVQ	R24, 56(R30)
+
+	MOVQ	R27, 64(R30)
+	BGE	R27, ab1
+	SUBQ	R27, R31, R27
+ab1:
+	MOVQ	R27, 8(R30)	/* numerator */
+
+	MOVQ	72(R30), R27
+	BGE	R27, ab2
+	SUBQ	R27, R31, R27
+ab2:
+	MOVQ	R27, 16(R30)	/* denominator */
+MOVQ	(R30), R10	/* debug */
+	RET
+
+/*
+ * restore registers and
+ * return to original caller
+ * answer is in R27
+ */
+TEXT	_retargq(SB), NOPROF, $-8
+	MOVQ	24(R30), R10
+	MOVQ	32(R30), R11
+	MOVQ	40(R30), R12
+	MOVQ	48(R30), R23
+	MOVQ	56(R30), R24
+	MOVL	0(R30), R26
+
+	ADDQ	$64, R30
+	RET			/* back to main sequence */
+
+TEXT	_divq(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVQ	R26, 0(R30)
+
+	JSR	_absargq(SB)
+	JSR	_udivmodq(SB)
+	MOVQ	8(R30), R27
+
+	MOVQ	64(R30), R10	/* clean up the sign */
+	MOVQ	72(R30), R11
+	XOR	R11, R10
+	BGE	R10, div1
+	SUBQ	R27, R31, R27
+div1:
+
+	JSR	_retargq(SB)
+	RET			/* not executed */
+
+TEXT	_divqu(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVQ	R26, 0(R30)
+
+	JSR	_unsargq(SB)
+	JSR	_udivmodq(SB)
+	MOVQ	8(R30), R27
+
+	JSR	_retargq(SB)
+	RET			/* not executed */
+
+TEXT	_modq(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVQ	R26, 0(R30)
+
+	JSR	_absargq(SB)
+	JSR	_udivmodq(SB)
+	MOVQ	16(R30), R27
+
+	MOVQ	64(R30), R10	/* clean up the sign */
+	BGE	R10, div2
+	SUBQ	R27, R31, R27
+div2:
+
+	JSR	_retargq(SB)
+	RET			/* not executed */
+
+TEXT	_modqu(SB), NOPROF, $-8
+	SUBQ	$64, R30	/* 5 reg save, 2 parameters, link */
+	MOVQ	R26, 0(R30)
+
+	JSR	_unsargq(SB)
+	JSR	_udivmodq(SB)
+	MOVQ	16(R30), R27
+
+	JSR	_retargq(SB)
+	RET			/* not executed */
+
diff --git a/sys/src/ape/lib/ap/alpha/getfcr.s b/sys/src/ape/lib/ap/alpha/getfcr.s
new file mode 100755
index 000000000..e3c9f02d8
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/getfcr.s
@@ -0,0 +1,33 @@
+TEXT	getfsr(SB), $8
+	TRAPB
+	MOVT	FPCR, F0
+	TRAPB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R0
+	RET
+
+TEXT	setfsr(SB), $8
+	SLLQ		$32, R0
+	MOVQ	R0, tmp-8(SP)
+	MOVT	tmp-8(SP), F0
+	TRAPB
+	MOVT	F0, FPCR
+	TRAPB
+	RET
+
+TEXT	getfcr(SB), $8
+	TRAPB
+	MOVT	FPCR, F0
+	TRAPB
+	MOVT	F0, tmp-8(SP)
+	MOVL	tmp-4(SP), R0
+	RET
+
+TEXT	setfcr(SB), $8
+	SLLQ		$32, R0
+	MOVQ	R0, tmp-8(SP)
+	MOVT	tmp-8(SP), F0
+	TRAPB
+	MOVT	F0, FPCR
+	TRAPB
+	RET
diff --git a/sys/src/ape/lib/ap/alpha/lock.c b/sys/src/ape/lib/ap/alpha/lock.c
new file mode 100755
index 000000000..91c0ba233
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/lock.c
@@ -0,0 +1,26 @@
+#define _LOCK_EXTENSION
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	while(tas(&lk->val))
+		_SLEEP(0);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/alpha/main9.s b/sys/src/ape/lib/ap/alpha/main9.s
new file mode 100755
index 000000000..43bdd7bd6
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/main9.s
@@ -0,0 +1,15 @@
+TEXT	_main(SB), 1, $16
+
+	MOVQ	$setSB(SB), R29
+	JSR	_envsetup(SB)
+	MOVL	inargc-8(FP), R0
+	MOVL	$inargv-4(FP), R1
+	MOVL	R0, 8(R30)
+	MOVL	R1, 12(R30)
+	JSR	main(SB)
+loop:
+	MOVL	R0, 8(R30)
+	JSR	exit(SB)
+	MOVQ	$_divq(SB), R31		/* force loading of divq */
+	MOVQ	$_divl(SB), R31			/* force loading of divl */
+	JMP	loop
diff --git a/sys/src/ape/lib/ap/alpha/main9p.s b/sys/src/ape/lib/ap/alpha/main9p.s
new file mode 100755
index 000000000..3312100cd
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/main9p.s
@@ -0,0 +1,48 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+	MOVQ	$setSB(SB), R29
+
+	/* _tos = arg */
+	MOVL	R0, _tos(SB)
+	MOVQ	$8(SP), R1
+	MOVL	R1, _privates(SB)
+	MOVQ	$NPRIVATES, R1
+	MOVL	R1, _nprivates(SB)
+
+	/* _profmain(); */
+	JSR	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVL	_tos+0(SB), R1
+	MOVL	4(R1), R2
+	MOVL	R2, 0(R1)
+
+	JSR	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVL	inargc-4(FP), R0
+	MOVL	$inargv+0(FP), R1
+	MOVL	environ(SB), R2
+	MOVL	R0, 8(R30)
+	MOVL	R1, 12(R30)
+	MOVL	R2, 16(R30)
+	JSR	main(SB)
+loop:
+	MOVL	R0, 8(R30)
+	JSR	exit(SB)
+	MOVQ	$_divq(SB), R31		/* force loading of divq */
+	MOVQ	$_divl(SB), R31		/* force loading of divl */
+	MOVQ	$_profin(SB), R31	/* force loading of profile */
+	JMP	loop
+
+TEXT	_savearg(SB), 1, $0
+	RET
+
+TEXT	_callpc(SB), 1, $0
+	MOVL	argp-8(FP), R0
+	RET
diff --git a/sys/src/ape/lib/ap/alpha/memcpy.c b/sys/src/ape/lib/ap/alpha/memcpy.c
new file mode 100755
index 000000000..7bbb55c6e
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/memcpy.c
@@ -0,0 +1,7 @@
+#include <string.h>
+
+void*
+memcpy(void *a1, const void *a2, size_t n)
+{
+	return memmove(a1, a2, n);
+}
diff --git a/sys/src/ape/lib/ap/alpha/memmove.s b/sys/src/ape/lib/ap/alpha/memmove.s
new file mode 100755
index 000000000..0fafb752d
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/memmove.s
@@ -0,0 +1,197 @@
+#define QUAD	8
+#define ALIGN	64
+#define BLOCK	64
+
+TEXT memmove(SB), $0
+	MOVL	from+4(FP), R7
+	MOVL	n+8(FP), R10
+	MOVQ	R0, R6
+
+	CMPUGE	R7, R0, R5
+	BNE	R5, _forward
+
+	MOVQ	R6, R8			/* end to address */
+	ADDL	R10, R6, R6		/* to+n */
+	ADDL	R10, R7, R7		/* from+n */
+
+	CMPUGE	$ALIGN, R10, R1		/* need at least ALIGN bytes */
+	BNE	R1, _b1tail
+
+_balign:
+	AND	$(ALIGN-1), R6, R1
+	BEQ	R1, _baligned
+
+	MOVBU	-1(R7), R2
+	ADDL	$-1, R6, R6
+	MOVB	R2, (R6)
+	ADDL	$-1, R7, R7
+	JMP	_balign
+	
+_baligned:
+	AND	$(QUAD-1), R7, R1	/* is the source quad-aligned */
+	BNE	R1, _bunaligned
+
+	ADDL	$(BLOCK-1), R8, R9
+_bblock:
+	CMPUGE	R9, R6, R1
+	BNE	R1, _b8tail
+
+	MOVQ	-64(R7), R22
+	MOVQ	-56(R7), R23
+	MOVQ	-48(R7), R24
+	MOVQ	-40(R7), R25
+	MOVQ	-32(R7), R2
+	MOVQ	-24(R7), R3
+	MOVQ	-16(R7), R4
+	MOVQ	-8(R7), R5
+
+	SUBL	$64, R6, R6
+	SUBL	$64, R7, R7
+
+	MOVQ	R22, (R6)
+	MOVQ	R23, 8(R6)
+	MOVQ	R24, 16(R6)
+	MOVQ	R25, 24(R6)
+	MOVQ	R2, 32(R6)
+	MOVQ	R3, 40(R6)
+	MOVQ	R4, 48(R6)
+	MOVQ	R5, 56(R6)
+	JMP	_bblock
+
+_b8tail:
+	ADDL	$(QUAD-1), R8, R9
+_b8block:
+	CMPUGE	R9, R6, R1
+	BNE	R1, _b1tail
+
+	MOVQ	-8(R7), R2
+	SUBL	$8, R6
+	MOVQ	R2, (R6)
+	SUBL	$8, R7
+	JMP	_b8block
+
+_b1tail:
+	CMPUGE	R8, R6, R1
+	BNE	R1, _ret
+
+	MOVBU	-1(R7), R2
+	SUBL	$1, R6, R6
+	MOVB	R2, (R6)
+	SUBL	$1, R7, R7
+	JMP	_b1tail
+_ret:
+	RET
+
+_bunaligned:
+	ADDL	$(16-1), R8, R9
+
+_bu8block:
+	CMPUGE	R9, R6, R1
+	BNE	R1, _b1tail
+
+	MOVQU	-16(R7), R4
+	MOVQU	-8(R7), R3
+	MOVQU	(R7), R2
+	SUBL	$16, R6
+	EXTQH	R7, R2, R2
+	EXTQL	R7, R3, R5
+	OR	R5, R2, R11
+	EXTQH	R7, R3, R3
+	EXTQL	R7, R4, R4
+	OR	R3, R4, R13
+	MOVQ	R11, 8(R6)
+	MOVQ	R13, (R6)
+	SUBL	$16, R7
+	JMP	_bu8block
+
+_forward:
+	ADDL	R10, R6, R8		/* end to address */
+
+	CMPUGE	$ALIGN, R10, R1		/* need at least ALIGN bytes */
+	BNE	R1, _f1tail
+
+_falign:
+	AND	$(ALIGN-1), R6, R1
+	BEQ	R1, _faligned
+
+	MOVBU	(R7), R2
+	ADDL	$1, R6, R6
+	ADDL	$1, R7, R7
+	MOVB	R2, -1(R6)
+	JMP	_falign
+
+_faligned:
+	AND	$(QUAD-1), R7, R1	/* is the source quad-aligned */
+	BNE	R1, _funaligned
+
+	SUBL	$(BLOCK-1), R8, R9
+_fblock:
+	CMPUGT	R9, R6, R1
+	BEQ	R1, _f8tail
+
+	MOVQ	(R7), R2
+	MOVQ	8(R7), R3
+	MOVQ	16(R7), R4
+	MOVQ	24(R7), R5
+	MOVQ	32(R7), R22
+	MOVQ	40(R7), R23
+	MOVQ	48(R7), R24
+	MOVQ	56(R7), R25
+
+	ADDL	$64, R6, R6
+	ADDL	$64, R7, R7
+
+	MOVQ	R2, -64(R6)
+	MOVQ	R3, -56(R6)
+	MOVQ	R4, -48(R6)
+	MOVQ	R5, -40(R6)
+	MOVQ	R22, -32(R6)
+	MOVQ	R23, -24(R6)
+	MOVQ	R24, -16(R6)
+	MOVQ	R25, -8(R6)
+	JMP	_fblock
+
+_f8tail:
+	SUBL	$(QUAD-1), R8, R9
+_f8block:
+	CMPUGT	R9, R6, R1
+	BEQ	R1, _f1tail
+
+	MOVQ	(R7), R2
+	ADDL	$8, R6
+	ADDL	$8, R7
+	MOVQ	R2, -8(R6)
+	JMP	_f8block
+
+_f1tail:
+	CMPUGT	R8, R6, R1
+	BEQ	R1, _fret
+	MOVBU	(R7), R2
+	ADDL	$1, R6, R6
+	ADDL	$1, R7, R7
+	MOVB	R2, -1(R6)
+	JMP	_f1tail
+
+_fret:
+	RET
+
+_funaligned:
+	SUBL	$(16-1), R8, R9
+_fu8block:
+	CMPUGT	R9, R6, R1
+	BEQ	R1, _f1tail
+
+	MOVQU	(R7), R2
+	MOVQU	8(R7), R3
+	MOVQU	16(R7), R4
+	EXTQL	R7, R2, R2
+	EXTQH	R7, R3, R5
+	OR	R5, R2, R11
+	EXTQL	R7, R3, R3
+	MOVQ	R11, (R6)
+	EXTQH	R7, R4, R4
+	OR	R3, R4, R11
+	MOVQ	R11, 8(R6)
+	ADDL	$16, R6
+	ADDL	$16, R7
+	JMP	_fu8block
diff --git a/sys/src/ape/lib/ap/alpha/memset.s b/sys/src/ape/lib/ap/alpha/memset.s
new file mode 100755
index 000000000..e3cfd468b
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/memset.s
@@ -0,0 +1,61 @@
+TEXT memset(SB), $0
+	MOVL	R0, R6
+	MOVBU	data+4(FP), R2
+	MOVL	n+8(FP), R10
+
+	ADDL	R10, R0, R8
+
+	CMPUGE	$8, R10, R1		/* need at least 8 bytes */
+	BNE	R1, _1loop
+
+	SLLQ	$8, R2, R1		/* replicate the byte */
+	OR	R1, R2
+	SLLQ	$16, R2, R1
+	OR	R1, R2
+	SLLQ	$32, R2, R1
+	OR	R1, R2
+
+_align:
+	AND	$(8-1), R6, R1
+	BEQ	R1, _aligned
+
+	MOVB	R2, (R6)
+	ADDL	$1, R6, R6
+	JMP	_align
+
+_aligned:
+	SUBL	$(64-1), R8, R9		/* end pointer minus slop */
+_64loop:
+	CMPUGT	R9, R6, R1
+	BEQ	R1, _8tail
+
+	MOVQ	R2, (R6)
+	MOVQ	R2, 8(R6)
+	MOVQ	R2, 16(R6)
+	MOVQ	R2, 24(R6)
+	MOVQ	R2, 32(R6)
+	MOVQ	R2, 40(R6)
+	MOVQ	R2, 48(R6)
+	MOVQ	R2, 56(R6)
+	ADDL	$64, R6, R6
+	JMP	_64loop
+
+_8tail:
+	SUBL	$(8-1), R8, R9
+_8loop:
+	CMPUGT	R9, R6, R1
+	BEQ	R1, _1loop
+
+	MOVQ	R2, (R6)
+	ADDL	$8, R6
+	JMP	_8loop
+
+_1loop:
+	CMPUGT	R8, R6, R1
+	BEQ	R1, _ret
+	MOVB	R2, (R6)
+	ADDL	$1, R6
+	JMP	_1loop
+
+_ret:
+	RET
diff --git a/sys/src/ape/lib/ap/alpha/mkfile b/sys/src/ape/lib/ap/alpha/mkfile
new file mode 100755
index 000000000..6a1c3ca60
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/mkfile
@@ -0,0 +1,23 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	_seek.$O\
+	cycles.$O\
+	divl.$O\
+	divq.$O\
+	getfcr.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memcpy.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	tas.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/alpha/notetramp.c b/sys/src/ape/lib/ap/alpha/notetramp.c
new file mode 100755
index 000000000..6b1be6641
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r0 = ret;
+	if(ret == 0)
+		u->r0 = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP];
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/alpha/setjmp.s b/sys/src/ape/lib/ap/alpha/setjmp.s
new file mode 100755
index 000000000..3289029a7
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/setjmp.s
@@ -0,0 +1,24 @@
+TEXT	setjmp(SB), 1, $-8
+	MOVL	R30, (R0)
+	MOVL	R26, 4(R0)
+	MOVQ	$0, R0
+	RET
+
+TEXT	sigsetjmp(SB), 1, $-8
+	MOVL	savemask+4(FP), R3
+	MOVL	R3, 0(R0)
+	MOVL	$_psigblocked(SB), R3
+	MOVL	R3, 4(R0)
+	MOVL	R30, 8(R0)
+	MOVL	R26, 12(R0)
+	MOVQ	$0, R0
+	RET
+
+TEXT	longjmp(SB), 1, $-8
+	MOVL	r+4(FP), R3
+	BNE	R3, ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVQ	$1, R3		/* bless their pointed heads */
+ok:	MOVL	(R0), R30
+	MOVL	4(R0), R26
+	MOVL	R3, R0
+	RET
diff --git a/sys/src/ape/lib/ap/alpha/tas.s b/sys/src/ape/lib/ap/alpha/tas.s
new file mode 100755
index 000000000..8b3164c3a
--- /dev/null
+++ b/sys/src/ape/lib/ap/alpha/tas.s
@@ -0,0 +1,10 @@
+TEXT	tas(SB), $-8
+	MOVQ	R0, R1			/* l */
+tas1:
+	MOVLL	(R1), R0		/* l->key */
+	BNE	R0, tas2
+	MOVQ	$1, R2
+	MOVLC	R2, (R1)		/* l->key = 1 */
+	BEQ	R2, tas1		/* write failed, try again? */
+tas2:
+	RET
diff --git a/sys/src/ape/lib/ap/arm/cycles.c b/sys/src/ape/lib/ap/arm/cycles.c
new file mode 100755
index 000000000..1c32bc732
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/cycles.c
@@ -0,0 +1,5 @@
+void
+_cycles(unsigned long long *u)
+{
+	*u = 0;
+}
diff --git a/sys/src/ape/lib/ap/arm/div.s b/sys/src/ape/lib/ap/arm/div.s
new file mode 100755
index 000000000..2f7699c50
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/div.s
@@ -0,0 +1,118 @@
+Q	= 0
+N	= 1
+D	= 2
+CC	= 3
+TMP	= 11
+
+TEXT	save<>(SB), 1, $0
+	MOVW	R(Q), 0(FP)
+	MOVW	R(N), 4(FP)
+	MOVW	R(D), 8(FP)
+	MOVW	R(CC), 12(FP)
+
+	MOVW	R(TMP), R(Q)		/* numerator */
+	MOVW	20(FP), R(D)		/* denominator */
+	CMP	$0, R(D)
+	BNE	s1
+	MOVW	-1(R(D)), R(TMP)	/* divide by zero fault */
+s1:	RET
+
+TEXT	rest<>(SB), 1, $0
+	MOVW	0(FP), R(Q)
+	MOVW	4(FP), R(N)
+	MOVW	8(FP), R(D)
+	MOVW	12(FP), R(CC)
+/*
+ * return to caller
+ * of rest<>
+ */
+	MOVW	0(R13), R14
+	ADD	$20, R13
+	B	(R14)
+
+TEXT	div<>(SB), 1, $0
+	MOVW	$32, R(CC)
+/*
+ * skip zeros 8-at-a-time
+ */
+e1:
+	AND.S	$(0xff<<24),R(Q), R(N)
+	BNE	e2
+	SLL	$8, R(Q)
+	SUB.S	$8, R(CC)
+	BNE	e1
+	RET
+e2:
+	MOVW	$0, R(N)
+
+loop:
+/*
+ * shift R(N||Q) left one
+ */
+	SLL	$1, R(N)
+	CMP	$0, R(Q)
+	ORR.LT	$1, R(N)
+	SLL	$1, R(Q)
+
+/*
+ * compare numerator to denominator
+ * if less, subtract and set quotent bit
+ */
+	CMP	R(D), R(N)
+	ORR.HS	$1, R(Q)
+	SUB.HS	R(D), R(N)
+	SUB.S	$1, R(CC)
+	BNE	loop
+	RET
+
+TEXT	_div(SB), 1, $16
+	BL	save<>(SB)
+	CMP	$0, R(Q)
+	BGE	d1
+	RSB	$0, R(Q), R(Q)
+	CMP	$0, R(D)
+	BGE	d2
+	RSB	$0, R(D), R(D)
+d0:
+	BL	div<>(SB)		/* none/both neg */
+	MOVW	R(Q), R(TMP)
+	B	out
+d1:
+	CMP	$0, R(D)
+	BGE	d0
+	RSB	$0, R(D), R(D)
+d2:
+	BL	div<>(SB)		/* one neg */
+	RSB	$0, R(Q), R(TMP)
+	B	out
+
+TEXT	_mod(SB), 1, $16
+	BL	save<>(SB)
+	CMP	$0, R(D)
+	RSB.LT	$0, R(D), R(D)
+	CMP	$0, R(Q)
+	BGE	m1
+	RSB	$0, R(Q), R(Q)
+	BL	div<>(SB)		/* neg numerator */
+	RSB	$0, R(N), R(TMP)
+	B	out
+m1:
+	BL	div<>(SB)		/* pos numerator */
+	MOVW	R(N), R(TMP)
+	B	out
+
+TEXT	_divu(SB), 1, $16
+	BL	save<>(SB)
+	BL	div<>(SB)
+	MOVW	R(Q), R(TMP)
+	B	out
+
+TEXT	_modu(SB), 1, $16
+	BL	save<>(SB)
+	BL	div<>(SB)
+	MOVW	R(N), R(TMP)
+	B	out
+
+out:
+	BL	rest<>(SB)
+	B	out
diff --git a/sys/src/ape/lib/ap/arm/getfcr.s b/sys/src/ape/lib/ap/arm/getfcr.s
new file mode 100755
index 000000000..b27c7f082
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/getfcr.s
@@ -0,0 +1,16 @@
+
+TEXT	setfcr(SB), $4
+	MOVW	R0, FPCR
+	RET
+
+TEXT	getfcr(SB), $4
+	MOVW	FPCR, R0
+	RET
+
+TEXT	getfsr(SB), $0
+	MOVW	FPSR, R0
+	RET
+
+TEXT	setfsr(SB), $0
+	MOVW	R0, FPSR
+	RET
diff --git a/sys/src/ape/lib/ap/arm/lock.c b/sys/src/ape/lib/ap/arm/lock.c
new file mode 100755
index 000000000..91c0ba233
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/lock.c
@@ -0,0 +1,26 @@
+#define _LOCK_EXTENSION
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	while(tas(&lk->val))
+		_SLEEP(0);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/arm/main9.s b/sys/src/ape/lib/ap/arm/main9.s
new file mode 100755
index 000000000..cd04bea17
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/main9.s
@@ -0,0 +1,17 @@
+arg=0
+sp=13
+sb=12
+
+TEXT	_main(SB), 1, $16
+	MOVW	$setR12(SB), R(sb)
+	BL	_envsetup(SB)
+	MOVW	$inargv+0(FP), R(arg)
+	MOVW	R(arg), 8(R(sp))
+	MOVW	inargc-4(FP), R(arg)
+	MOVW	R(arg), 4(R(sp))
+	BL	main(SB)
+loop:
+	MOVW	R(arg), 4(R(sp))
+	BL	exit(SB)
+	BL	_div(SB)
+	B	loop
diff --git a/sys/src/ape/lib/ap/arm/main9p.s b/sys/src/ape/lib/ap/arm/main9p.s
new file mode 100755
index 000000000..f5dc65344
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/main9p.s
@@ -0,0 +1,52 @@
+arg=0
+sp=13
+sb=12
+
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+
+	MOVW	$setR12(SB), R(sb)
+
+	/* _tos = arg */
+	MOVW	R(arg), _tos(SB)
+	MOVW	$private+8(SP), R1
+	MOVW	R1, _privates(SB)
+	MOVW	$NPRIVATES, R1
+	MOVW	R1, _nprivates(SB)
+
+	/* _profmain(); */
+	BL	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVW	_tos+0(SB),R1
+	MOVW	4(R1), R2
+	MOVW	R2, 0(R1)
+
+	BL	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVW	$inargv+0(FP), R(arg)
+	MOVW	R(arg), 8(R(sp))
+	MOVW	inargc-4(FP), R(arg)
+	MOVW	R(arg), 4(R(sp))
+	MOVW	environ(SB), R(arg)
+	MOVW	R(arg), 8(R(sp))
+	BL	main(SB)
+loop:
+	MOVW	R(arg), 4(R(sp))
+	BL	exit(SB)
+	MOVW	$_div(SB), R(arg)	/* force loading of div */
+	MOVW	$_profin(SB), R(arg)	/* force loading of profile */
+	B	loop
+
+TEXT	_savearg(SB), 1, $0
+	RET
+
+TEXT	_callpc(SB), 1, $0
+	MOVW	argp-4(FP), R(arg)
+	RET
diff --git a/sys/src/ape/lib/ap/arm/memmove.s b/sys/src/ape/lib/ap/arm/memmove.s
new file mode 100755
index 000000000..346a23d72
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/memmove.s
@@ -0,0 +1,212 @@
+TS = 0
+TE = 1
+FROM = 2
+N = 3
+TMP = 3					/* N and TMP don't overlap */
+TMP1 = 4
+
+TEXT memcpy(SB), $-4
+	B	_memmove
+TEXT memmove(SB), $-4
+_memmove:
+	MOVW	R(TS), to+0(FP)		/* need to save for return value */
+	MOVW	from+4(FP), R(FROM)
+	MOVW	n+8(FP), R(N)
+
+	ADD	R(N), R(TS), R(TE)	/* to end pointer */
+
+	CMP	R(FROM), R(TS)
+	BLS	_forward
+
+_back:
+	ADD	R(N), R(FROM)		/* from end pointer */
+	CMP	$4, R(N)		/* need at least 4 bytes to copy */
+	BLT	_b1tail
+
+_b4align:				/* align destination on 4 */
+	AND.S	$3, R(TE), R(TMP)
+	BEQ	_b4aligned
+
+	MOVBU.W	-1(R(FROM)), R(TMP)	/* pre-indexed */
+	MOVBU.W	R(TMP), -1(R(TE))	/* pre-indexed */
+	B	_b4align
+
+_b4aligned:				/* is source now aligned? */
+	AND.S	$3, R(FROM), R(TMP)
+	BNE	_bunaligned
+
+	ADD	$31, R(TS), R(TMP)	/* do 32-byte chunks if possible */
+_b32loop:
+	CMP	R(TMP), R(TE)
+	BLS	_b4tail
+
+	MOVM.DB.W (R(FROM)), [R4-R7]
+	MOVM.DB.W [R4-R7], (R(TE))
+	MOVM.DB.W (R(FROM)), [R4-R7]
+	MOVM.DB.W [R4-R7], (R(TE))
+	B	_b32loop
+
+_b4tail:				/* do remaining words if possible */
+	ADD	$3, R(TS), R(TMP)
+_b4loop:
+	CMP	R(TMP), R(TE)
+	BLS	_b1tail
+
+	MOVW.W	-4(R(FROM)), R(TMP1)	/* pre-indexed */
+	MOVW.W	R(TMP1), -4(R(TE))	/* pre-indexed */
+	B	_b4loop
+
+_b1tail:				/* remaining bytes */
+	CMP	R(TE), R(TS)
+	BEQ	_return
+
+	MOVBU.W	-1(R(FROM)), R(TMP)	/* pre-indexed */
+	MOVBU.W	R(TMP), -1(R(TE))	/* pre-indexed */
+	B	_b1tail
+
+_forward:
+	CMP	$4, R(N)		/* need at least 4 bytes to copy */
+	BLT	_f1tail
+
+_f4align:				/* align destination on 4 */
+	AND.S	$3, R(TS), R(TMP)
+	BEQ	_f4aligned
+
+	MOVBU.P	1(R(FROM)), R(TMP)	/* implicit write back */
+	MOVBU.P	R(TMP), 1(R(TS))	/* implicit write back */
+	B	_f4align
+
+_f4aligned:				/* is source now aligned? */
+	AND.S	$3, R(FROM), R(TMP)
+	BNE	_funaligned
+
+	SUB	$31, R(TE), R(TMP)	/* do 32-byte chunks if possible */
+_f32loop:
+	CMP	R(TMP), R(TS)
+	BHS	_f4tail
+
+	MOVM.IA.W (R(FROM)), [R4-R7] 
+	MOVM.IA.W [R4-R7], (R(TS))
+	MOVM.IA.W (R(FROM)), [R4-R7] 
+	MOVM.IA.W [R4-R7], (R(TS))
+	B	_f32loop
+
+_f4tail:
+	SUB	$3, R(TE), R(TMP)	/* do remaining words if possible */
+_f4loop:
+	CMP	R(TMP), R(TS)
+	BHS	_f1tail
+
+	MOVW.P	4(R(FROM)), R(TMP1)	/* implicit write back */
+	MOVW.P	R4, 4(R(TS))		/* implicit write back */
+	B	_f4loop
+
+_f1tail:
+	CMP	R(TS), R(TE)
+	BEQ	_return
+
+	MOVBU.P	1(R(FROM)), R(TMP)	/* implicit write back */
+	MOVBU.P	R(TMP), 1(R(TS))	/* implicit write back */
+	B	_f1tail
+
+_return:
+	MOVW	to+0(FP), R0
+	RET
+
+RSHIFT = 4
+LSHIFT = 5
+OFFSET = 11
+
+BR0 = 6
+BW0 = 7
+BR1 = 7
+BW1 = 8
+
+_bunaligned:
+	CMP	$2, R(TMP)		/* is R(TMP) < 2 ? */
+
+	MOVW.LT	$8, R(RSHIFT)		/* (R(n)<<24)|(R(n-1)>>8) */
+	MOVW.LT	$24, R(LSHIFT)
+	MOVW.LT	$1, R(OFFSET)
+
+	MOVW.EQ	$16, R(RSHIFT)		/* (R(n)<<16)|(R(n-1)>>16) */
+	MOVW.EQ	$16, R(LSHIFT)
+	MOVW.EQ	$2, R(OFFSET)
+
+	MOVW.GT	$24, R(RSHIFT)		/* (R(n)<<8)|(R(n-1)>>24) */
+	MOVW.GT	$8, R(LSHIFT)
+	MOVW.GT	$3, R(OFFSET)
+
+	ADD	$8, R(TS), R(TMP)	/* do 8-byte chunks if possible */
+	CMP	R(TMP), R(TE)
+	BLS	_b1tail
+
+	BIC	$3, R(FROM)		/* align source */
+	MOVW	(R(FROM)), R(BR0)	/* prime first block register */
+
+_bu8loop:
+	CMP	R(TMP), R(TE)
+	BLS	_bu1tail
+
+	MOVW	R(BR0)<<R(LSHIFT), R(BW1)
+	MOVM.DB.W (R(FROM)), [R(BR0)-R(BR1)]
+	ORR	R(BR1)>>R(RSHIFT), R(BW1)
+
+	MOVW	R(BR1)<<R(LSHIFT), R(BW0)
+	ORR	R(BR0)>>R(RSHIFT), R(BW0)
+
+	MOVM.DB.W [R(BW0)-R(BW1)], (R(TE))
+	B	_bu8loop
+
+_bu1tail:
+	ADD	R(OFFSET), R(FROM)
+	B	_b1tail
+
+RSHIFT = 4
+LSHIFT = 5
+OFFSET = 11
+
+FW0 = 6
+FR0 = 7
+FW1 = 7
+FR1 = 8
+
+_funaligned:
+	CMP	$2, R(TMP)
+
+	MOVW.LT	$8, R(RSHIFT)		/* (R(n+1)<<24)|(R(n)>>8) */
+	MOVW.LT	$24, R(LSHIFT)
+	MOVW.LT	$3, R(OFFSET)
+
+	MOVW.EQ	$16, R(RSHIFT)		/* (R(n+1)<<16)|(R(n)>>16) */
+	MOVW.EQ	$16, R(LSHIFT)
+	MOVW.EQ	$2, R(OFFSET)
+
+	MOVW.GT	$24, R(RSHIFT)		/* (R(n+1)<<8)|(R(n)>>24) */
+	MOVW.GT	$8, R(LSHIFT)
+	MOVW.GT	$1, R(OFFSET)
+
+	SUB	$8, R(TE), R(TMP)	/* do 8-byte chunks if possible */
+	CMP	R(TMP), R(TS)
+	BHS	_f1tail
+
+	BIC	$3, R(FROM)		/* align source */
+	MOVW.P	4(R(FROM)), R(FR1)	/* prime last block register, implicit write back */
+
+_fu8loop:
+	CMP	R(TMP), R(TS)
+	BHS	_fu1tail
+
+	MOVW	R(FR1)>>R(RSHIFT), R(FW0)
+	MOVM.IA.W (R(FROM)), [R(FR0)-R(FR1)]
+	ORR	R(FR0)<<R(LSHIFT), R(FW0)
+
+	MOVW	R(FR0)>>R(RSHIFT), R(FW1)
+	ORR	R(FR1)<<R(LSHIFT), R(FW1)
+
+	MOVM.IA.W [R(FW0)-R(FW1)], (R(TS))
+	B	_fu8loop
+
+_fu1tail:
+	SUB	R(OFFSET), R(FROM)
+	B	_f1tail
diff --git a/sys/src/ape/lib/ap/arm/memset.s b/sys/src/ape/lib/ap/arm/memset.s
new file mode 100755
index 000000000..7ebbb44c3
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/memset.s
@@ -0,0 +1,60 @@
+TO = 1
+TOE = 2
+N = 3
+TMP = 3					/* N and TMP don't overlap */
+
+TEXT memset(SB), $0
+	MOVW	R0, R(TO)
+	MOVW	data+4(FP), R(4)
+	MOVW	n+8(FP), R(N)
+
+	ADD	R(N), R(TO), R(TOE)	/* to end pointer */
+
+	CMP	$4, R(N)		/* need at least 4 bytes to copy */
+	BLT	_1tail
+
+	AND	$0xFF, R(4)
+	ORR	R(4)<<8, R(4)
+	ORR	R(4)<<16, R(4)		/* replicate to word */
+
+_4align:				/* align on 4 */
+	AND.S	$3, R(TO), R(TMP)
+	BEQ	_4aligned
+
+	MOVBU.P	R(4), 1(R(TO))		/* implicit write back */
+	B	_4align
+
+_4aligned:
+	SUB	$15, R(TOE), R(TMP)	/* do 16-byte chunks if possible */
+	CMP	R(TMP), R(TO)
+	BHS	_4tail
+
+	MOVW	R4, R5			/* replicate */
+	MOVW	R4, R6
+	MOVW	R4, R7
+
+_f16loop:
+	CMP	R(TMP), R(TO)
+	BHS	_4tail
+
+	MOVM.IA.W [R4-R7], (R(TO))
+	B	_f16loop
+
+_4tail:
+	SUB	$3, R(TOE), R(TMP)	/* do remaining words if possible */
+_4loop:
+	CMP	R(TMP), R(TO)
+	BHS	_1tail
+
+	MOVW.P	R(4), 4(R(TO))		/* implicit write back */
+	B	_4loop
+
+_1tail:
+	CMP	R(TO), R(TOE)
+	BEQ	_return
+
+	MOVBU.P	R(4), 1(R(TO))		/* implicit write back */
+	B	_1tail
+
+_return:
+	RET
diff --git a/sys/src/ape/lib/ap/arm/mkfile b/sys/src/ape/lib/ap/arm/mkfile
new file mode 100755
index 000000000..f65e34395
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/mkfile
@@ -0,0 +1,25 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	div.$O\
+	getfcr.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strchr.$O\
+	strcmp.$O\
+	strcpy.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/arm/notetramp.c b/sys/src/ape/lib/ap/arm/notetramp.c
new file mode 100755
index 000000000..6b1be6641
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r0 = ret;
+	if(ret == 0)
+		u->r0 = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP];
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/arm/setjmp.s b/sys/src/ape/lib/ap/arm/setjmp.s
new file mode 100755
index 000000000..62a06245c
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/setjmp.s
@@ -0,0 +1,29 @@
+arg=0
+link=14
+sp=13
+
+TEXT	setjmp(SB), 1, $-4
+	MOVW	R(sp), (R(arg+0))
+	MOVW	R(link), 4(R(arg+0))
+	MOVW	$0, R0
+	RET
+
+TEXT	sigsetjmp(SB), 1, $-4
+	MOVW	savemask+4(FP), R(arg+2)
+	MOVW	R(arg+2), 0(R(arg+0))
+	MOVW	$_psigblocked(SB), R(arg+2)
+	MOVW	R2, 4(R(arg+0))
+	MOVW	R(sp), 8(R(arg+0))
+	MOVW	R(link), 12(R(arg+0))
+	MOVW	$0, R(arg+0)
+	RET
+
+TEXT	longjmp(SB), 1, $-4
+	MOVW	r+4(FP), R(arg+2)
+	CMP	$0, R(arg+2)
+	BNE	ok			/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVW	$1, R(arg+2)		/* bless their pointed heads */
+ok:	MOVW	(R(arg+0)), R(sp)
+	MOVW	4(R(arg+0)), R(link)
+	MOVW	R(arg+2), R(arg+0)
+	RET
diff --git a/sys/src/ape/lib/ap/arm/strchr.s b/sys/src/ape/lib/ap/arm/strchr.s
new file mode 100755
index 000000000..349b5a49f
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/strchr.s
@@ -0,0 +1,56 @@
+TEXT strchr(SB), $-4
+	MOVBU	c+4(FP), R1
+	CMP	$0, R1
+	BEQ	_null
+
+_strchr:				/* not looking for a null, byte at a time */
+	MOVBU.P	1(R0), R2
+	CMP	R1, R2
+	BEQ	_sub1
+
+	CMP	$0, R2
+	BNE	_strchr
+
+_return0:				/* character not found in string, return 0 */
+	MOVW	$0, R0
+	RET
+
+_null:					/* looking for null, align */
+	AND.S	$3, R0, R2
+	BEQ	_aligned
+
+	MOVBU.P	1(R0), R4
+	CMP	$0, R4
+	BEQ	_sub1
+	B	_null
+
+_aligned:
+	MOVW	$0xFF, R3		/* mask */
+
+_loop:
+	MOVW.P	4(R0), R4		/* 4 at a time */
+	TST	R4, R3			/* AND.S R2, R3, Rx */
+	TST.NE	R4>>8, R3
+	TST.NE	R4>>16, R3
+	TST.NE	R4>>24, R3
+	BNE	_loop
+
+	TST	R4, R3			/* its somewhere, find it and correct */
+	BEQ	_sub4
+	TST	R4>>8, R3
+	BEQ	_sub3
+	TST	R4>>16, R3
+	BEQ	_sub2
+
+_sub1:					/* compensate for pointer increment */
+	SUB	$1, R0
+	RET
+_sub2:
+	SUB	$2, R0
+	RET
+_sub3:
+	SUB	$3, R0
+	RET
+_sub4:
+	SUB	$4, R0
+	RET
diff --git a/sys/src/ape/lib/ap/arm/strcmp.s b/sys/src/ape/lib/ap/arm/strcmp.s
new file mode 100755
index 000000000..015e51596
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/strcmp.s
@@ -0,0 +1,67 @@
+TEXT strcmp(SB), $-4
+	MOVW	R0, R1
+	MOVW	s2+4(FP), R2
+
+	MOVW	$0xFF, R3		/* mask */
+
+_align:					/* align s1 on 4 */
+	TST	$3, R1
+	BEQ	_aligned
+
+	MOVBU.P	1(R1), R4		/* implicit write back */
+	MOVBU.P	1(R2), R8		/* implicit write back */
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+	B	_align
+
+_aligned:				/* is s2 now aligned? */
+	TST	$3, R2
+	BNE	_unaligned
+
+_aloop:
+	MOVW.P	4(R1), R5		/* 4 at a time */
+	MOVW.P	4(R2), R7
+
+	AND	R5, R3, R4
+	AND	R7, R3, R8
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+
+	AND	R5>>8, R3, R4
+	AND	R7>>8, R3, R8
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+
+	AND	R5>>16, R3, R4
+	AND	R7>>16, R3, R8
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+
+	AND	R5>>24, R3, R4
+	AND	R7>>24, R3, R8
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+
+	B	_aloop
+
+_return:
+	RET
+
+_unaligned:
+	MOVBU.P	1(R1), R4		/* implicit write back */
+	MOVBU.P	1(R2), R8		/* implicit write back */
+	SUB.S	R8, R4, R0
+	BNE	_return
+	CMP	$0, R4
+	BEQ	_return
+	B	_unaligned
diff --git a/sys/src/ape/lib/ap/arm/strcpy.s b/sys/src/ape/lib/ap/arm/strcpy.s
new file mode 100755
index 000000000..3e69fdc7d
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/strcpy.s
@@ -0,0 +1,46 @@
+TEXT strcpy(SB), $-4
+	MOVW		R0, to+0(FP)	/* need to save for return value */
+	MOVW		from+4(FP), R1
+	MOVW		$0xFF, R2	/* mask */
+
+salign:					/* align source on 4 */
+	AND.S		$3, R1, R3
+	BEQ		dalign
+	MOVBU.P		1(R1), R3	/* implicit write back */
+	TST		R3, R2
+	MOVBU.P		R3, 1(R0)	/* implicit write back */
+	BNE		salign
+	B		return
+
+dalign:				/* is destination now aligned? */
+	AND.S		$3, R0, R3
+	BNE		uloop
+
+aloop:
+	MOVW.P		4(R1), R4	/* read 4, write 4 */
+	TST		R4, R2		/* AND.S R3, R2, Rx */
+	TST.NE		R4>>8, R2
+	TST.NE		R4>>16, R2
+	TST.NE		R4>>24, R2
+	BEQ		tail
+	MOVW.P		R4, 4(R0)
+	B		aloop
+
+uloop:
+	MOVW.P		4(R1), R4	/* read 4, write 1,1,1,1 */
+
+tail:
+	AND.S		R4, R2, R3
+	MOVBU.NE.P	R3, 1(R0)
+	AND.NE.S	R4>>8, R2, R3
+	MOVBU.NE.P	R3, 1(R0)
+	AND.NE.S	R4>>16, R2, R3
+	MOVBU.NE.P	R3, 1(R0)
+	AND.NE.S	R4>>24, R2, R3
+	MOVBU.P		R3, 1(R0)
+	BNE		uloop
+	B		return
+
+return:
+	MOVW		to+0(FP), R0
+	RET
diff --git a/sys/src/ape/lib/ap/arm/tas.s b/sys/src/ape/lib/ap/arm/tas.s
new file mode 100755
index 000000000..f1269209e
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/tas.s
@@ -0,0 +1,5 @@
+TEXT	tas(SB), $-4
+	MOVW	R0,R1
+	MOVW	$1,R0
+	SWPW	R0,(R1)
+	RET
diff --git a/sys/src/ape/lib/ap/arm/vlop.s b/sys/src/ape/lib/ap/arm/vlop.s
new file mode 100755
index 000000000..3a5375541
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/vlop.s
@@ -0,0 +1,13 @@
+TEXT	_mulv(SB), $0
+	MOVW	4(FP),R8	/* l0 */
+	MOVW	8(FP),R11	/* h0 */
+	MOVW	12(FP),R4	/* l1 */
+	MOVW	16(FP),R5	/* h1 */
+	MULLU	R8,R4,(R6, R7)	/* l0*l1 */
+	MUL	R8,R5,R5	/* l0*h1 */
+	MUL	R11,R4,R4	/* h0*l1 */
+	ADD	R4,R6
+	ADD	R5,R6
+	MOVW	R6,4(R0)
+	MOVW	R7,0(R0)
+	RET
diff --git a/sys/src/ape/lib/ap/arm/vlrt.c b/sys/src/ape/lib/ap/arm/vlrt.c
new file mode 100755
index 000000000..5e9524d34
--- /dev/null
+++ b/sys/src/ape/lib/ap/arm/vlrt.c
@@ -0,0 +1,708 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	ulong	lo;
+	ulong	hi;
+};
+
+void	abort(void);
+
+/* needed by profiler; can't be profiled */
+#pragma profile off
+
+void
+_addv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo + b.lo;
+	hi = a.hi + b.hi;
+	if(lo < a.lo)
+		hi++;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_subv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo - b.lo;
+	hi = a.hi - b.hi;
+	if(lo > a.lo)
+		hi--;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+#pragma profile on
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; struct Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+
+static void
+dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
+{
+	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
+	int i;
+
+	numhi = num.hi;
+	numlo = num.lo;
+	denhi = den.hi;
+	denlo = den.lo;
+	/*
+	 * get a divide by zero
+	 */
+	if(denlo==0 && denhi==0) {
+		numlo = numlo / denlo;
+	}
+
+	/*
+	 * set up the divisor and find the number of iterations needed
+	 */
+	if(numhi >= SIGN(32)) {
+		quohi = SIGN(32);
+		quolo = 0;
+	} else {
+		quohi = numhi;
+		quolo = numlo;
+	}
+	i = 0;
+	while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
+		denhi = (denhi<<1) | (denlo>>31);
+		denlo <<= 1;
+		i++;
+	}
+
+	quohi = 0;
+	quolo = 0;
+	for(; i >= 0; i--) {
+		quohi = (quohi<<1) | (quolo>>31);
+		quolo <<= 1;
+		if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
+			t = numlo;
+			numlo -= denlo;
+			if(numlo > t)
+				numhi--;
+			numhi -= denhi;
+			quolo |= 1;
+		}
+		denlo = (denlo>>1) | (denhi<<31);
+		denhi >>= 1;
+	}
+
+	if(q) {
+		q->lo = quolo;
+		q->hi = quohi;
+	}
+	if(r) {
+		r->lo = numlo;
+		r->hi = numhi;
+	}
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	dodiv(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	dodiv(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_rshav(Vlong *r, Vlong a, int b)
+{
+	long t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = t>>31;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = t>>31;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_rshlv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = 0;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_lshv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.lo;
+	if(b >= 32) {
+		r->lo = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->hi = 0;
+			return;
+		}
+		r->hi = t << (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->lo = t;
+		r->hi = a.hi;
+		return;
+	}
+	r->lo = t << b;
+	r->hi = (t >> (32-b)) | (a.hi << b);
+}
+
+void
+_andv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi & b.hi;
+	r->lo = a.lo & b.lo;
+}
+
+void
+_orv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi | b.hi;
+	r->lo = a.lo | b.lo;
+}
+
+void
+_xorv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi ^ b.hi;
+	r->lo = a.lo ^ b.lo;
+}
+
+void
+_vpp(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+}
+
+void
+_vmm(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+}
+
+void
+_ppv(Vlong *l, Vlong *r)
+{
+
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_mmv(Vlong *l, Vlong *r)
+{
+
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u = *ret;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
+
+void
+_p2v(Vlong *ret, void *p)
+{
+	long t;
+
+	t = (ulong)p;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sl2v(Vlong *ret, long sl)
+{
+	long t;
+
+	t = sl;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ul2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_si2v(Vlong *ret, int si)
+{
+	long t;
+
+	t = si;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ui2v(Vlong *ret, uint ui)
+{
+	long t;
+
+	t = ui;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sh2v(Vlong *ret, long sh)
+{
+	long t;
+
+	t = (sh << 16) >> 16;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uh2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xffff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sc2v(Vlong *ret, long uc)
+{
+	long t;
+
+	t = (uc << 24) >> 24;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uc2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+long
+_v2sc(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xff;
+	return (t << 24) >> 24;
+}
+
+long
+_v2uc(Vlong rv)
+{
+
+	return rv.lo & 0xff;
+}
+
+long
+_v2sh(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xffff;
+	return (t << 16) >> 16;
+}
+
+long
+_v2uh(Vlong rv)
+{
+
+	return rv.lo & 0xffff;
+}
+
+long
+_v2sl(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ul(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2si(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ui(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+int
+_testv(Vlong rv)
+{
+	return rv.lo || rv.hi;
+}
+
+int
+_eqv(Vlong lv, Vlong rv)
+{
+	return lv.lo == rv.lo && lv.hi == rv.hi;
+}
+
+int
+_nev(Vlong lv, Vlong rv)
+{
+	return lv.lo != rv.lo || lv.hi != rv.hi;
+}
+
+int
+_ltv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_gtv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_gev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
+
+int
+_lov(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lsv(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_hiv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_hsv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
diff --git a/sys/src/ape/lib/ap/extraobjs b/sys/src/ape/lib/ap/extraobjs
new file mode 100755
index 000000000..66974b2cf
--- /dev/null
+++ b/sys/src/ape/lib/ap/extraobjs
@@ -0,0 +1,37 @@
+#!/bin/rc
+switch($objtype){
+case mips
+	echo G_strcat.$O 9_strchr.$O 9_strcmp.$O 9_strcpy.$O G_strlen.$O\
+	G_strncmp.$O G_strrchr.$O 9_memchr.$O 9_memcmp.$O 9_memmove.$O\
+	9_memset.$O 9_getfcr.$O 9_vlop.$O 9_vlrt.$O
+
+case 68020
+	echo 9_strcat.$O 9_strchr.$O 9_strcmp.$O 9_strcpy.$O 9_strlen.$O\
+	G_strncmp.$O G_strrchr.$O 9_memchr.$O 9_memcmp.$O 9_memcpy.$O\
+	9_memmove.$O 9_memset.$O 9_vlop.$O 9_vlrt.$O
+
+case 386
+	echo 9_strcat.$O 9_strchr.$O G_strcmp.$O 9_strcpy.$O 9_strlen.$O\
+	G_strncmp.$O G_strrchr.$O 9_memchr.$O 9_memcmp.$O 9_memcpy.$O\
+	9_memmove.$O 9_memset.$O 9_vlop.$O 9_vlrt.$O
+
+case arm
+	echo 9_strcat.$O 9_strchr.$O G_strcmp.$O 9_strcpy.$O 9_strlen.$O\
+	G_strncmp.$O G_strrchr.$O 9_memchr.$O 9_memcmp.$O\
+	9_memmove.$O 9_memset.$O 9_vlop.$O 9_vlrt.$O 9_div.$O
+
+case sparc
+	echo G_strcat.$O 9_strchr.$O 9_strcmp.$O 9_strcpy.$O G_strlen.$O\
+	G_strncmp.$O G_strrchr.$O 9_memchr.$O 9_memcmp.$O 9_memmove.$O\
+	9_memset.$O 9_muldiv.$O 9_vlop.$O 9_vlrt.$O
+
+case alpha
+	echo G_strcat.$O G_strchr.$O G_strcmp.$O G_strcpy.$O G_strlen.$O\
+	G_strncmp.$O G_strrchr.$O G_memchr.$O G_memcmp.$O 9_memmove.$O\
+	9_memset.$O 9_memcpy.$O 9_getfcr.$O 9_divl.$O 9_divq.$O
+
+case power
+	echo G_strcat.$O G_strchr.$O G_strcmp.$O G_strcpy.$O G_strlen.$O\
+	G_strncmp.$O G_strrchr.$O G_memchr.$O 9_memcmp.$O 9_memmove.$O\
+	9_memset.$O 9_getfcr.$O 9_vlop.$O 9_vlrt.$O
+}
diff --git a/sys/src/ape/lib/ap/gen/_assert.c b/sys/src/ape/lib/ap/gen/_assert.c
new file mode 100755
index 000000000..e39e147a4
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/_assert.c
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <assert.h>
+
+void
+_assert(char *f, unsigned line)
+{
+	char buf[20], *p, *s = &buf[20];
+	write(2, "assertion failed: file ", 23);
+	for(p = f; *p; p++) continue;
+	write(2, f, p-f);
+	write(2, ":", 7);
+	*--s = '\n';
+	do *--s = line%10 + '0'; while (line /= 10);
+	write(2, s, &buf[20] - s);
+	abort();
+	
+}
diff --git a/sys/src/ape/lib/ap/gen/abort.c b/sys/src/ape/lib/ap/gen/abort.c
new file mode 100755
index 000000000..67b878541
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/abort.c
@@ -0,0 +1,9 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+
+void
+abort(void)
+{
+	kill(getpid(), SIGABRT);
+}
diff --git a/sys/src/ape/lib/ap/gen/abs.c b/sys/src/ape/lib/ap/gen/abs.c
new file mode 100755
index 000000000..7d670ffb3
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/abs.c
@@ -0,0 +1,17 @@
+#include <stdlib.h>
+
+int
+abs(int a)
+{
+	if(a < 0)
+		return -a;
+	return a;
+}
+
+long
+labs(long a)
+{
+	if(a < 0)
+		return -a;
+	return a;
+}
diff --git a/sys/src/ape/lib/ap/gen/atof.c b/sys/src/ape/lib/ap/gen/atof.c
new file mode 100755
index 000000000..63b8bfea4
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/atof.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+double
+atof(const char *s)
+{
+	return(strtod(s, (char **)0));
+}
diff --git a/sys/src/ape/lib/ap/gen/atoi.c b/sys/src/ape/lib/ap/gen/atoi.c
new file mode 100755
index 000000000..8b9bddd41
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/atoi.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+int
+atoi(const char *s)
+{
+	return(strtol(s, (char **)0, 10));
+}
diff --git a/sys/src/ape/lib/ap/gen/atol.c b/sys/src/ape/lib/ap/gen/atol.c
new file mode 100755
index 000000000..41e6040fe
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/atol.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+long
+atol(const char *s)
+{
+	return(strtol(s, (char **)0, 10));
+}
diff --git a/sys/src/ape/lib/ap/gen/atoll.c b/sys/src/ape/lib/ap/gen/atoll.c
new file mode 100755
index 000000000..55f28000a
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/atoll.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+long long
+atoll(const char *s)
+{
+	return(strtoll(s, (char **)0, 10));
+}
diff --git a/sys/src/ape/lib/ap/gen/bsearch.c b/sys/src/ape/lib/ap/gen/bsearch.c
new file mode 100755
index 000000000..ae0342f99
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/bsearch.c
@@ -0,0 +1,24 @@
+#include <stdlib.h>
+#include <stdio.h>
+void*
+bsearch(const void* key, const void* base, size_t nmemb, size_t size,
+		int (*compar)(const void*, const void*))
+{
+	long i, bot, top, new;
+	void *p;
+
+	bot = 0;
+	top = bot + nmemb - 1;
+	while(bot <= top){
+		new = (top + bot)/2;
+		p = (char *)base+new*size;
+		i = (*compar)(key, p);
+		if(i == 0)
+			return p;
+		if(i > 0)
+			bot = new + 1;
+		else
+			top = new - 1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/calloc.c b/sys/src/ape/lib/ap/gen/calloc.c
new file mode 100755
index 000000000..e52210d84
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/calloc.c
@@ -0,0 +1,13 @@
+#include <stdlib.h>
+#include <string.h>
+
+void *
+calloc(size_t nmemb, size_t size)
+{
+	void *mp;
+
+	nmemb = nmemb*size;
+	if(mp = malloc(nmemb))
+		memset(mp, 0, nmemb);
+	return(mp);
+}
diff --git a/sys/src/ape/lib/ap/gen/clock.c b/sys/src/ape/lib/ap/gen/clock.c
new file mode 100755
index 000000000..d7d5d4b67
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/clock.c
@@ -0,0 +1,12 @@
+#include <time.h>
+#include <sys/times.h>
+
+clock_t
+clock(void)
+{
+	struct tms t;
+
+	if(times(&t) == (clock_t)-1)
+		return (clock_t)-1;
+	return t.tms_utime+t.tms_stime;
+}
diff --git a/sys/src/ape/lib/ap/gen/ctype.c b/sys/src/ape/lib/ap/gen/ctype.c
new file mode 100755
index 000000000..3829a171a
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/ctype.c
@@ -0,0 +1,56 @@
+#include <ctype.h>
+
+unsigned char	_ctype[] =
+{
+/* 	0			1			2			3  */
+/* 	4			5			6			7  */
+
+/*  0*/	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+/* 10*/	_IScntrl,		_ISspace|_IScntrl,	_ISspace|_IScntrl,	_ISspace|_IScntrl,
+	_ISspace|_IScntrl,	_ISspace|_IScntrl,	_IScntrl,		_IScntrl,
+/* 20*/	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+/* 30*/	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+	_IScntrl,		_IScntrl,		_IScntrl,		_IScntrl,
+/* 40*/	_ISspace|_ISblank,	_ISpunct,		_ISpunct,		_ISpunct,
+	_ISpunct,		_ISpunct,		_ISpunct,		_ISpunct,
+/* 50*/	_ISpunct,		_ISpunct,		_ISpunct,		_ISpunct,
+	_ISpunct,		_ISpunct,		_ISpunct,		_ISpunct,
+/* 60*/	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,
+	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,
+/* 70*/	_ISdigit|_ISxdigit,	_ISdigit|_ISxdigit,	_ISpunct,		_ISpunct,
+	_ISpunct,		_ISpunct,		_ISpunct,		_ISpunct,
+/*100*/	_ISpunct,		_ISupper|_ISxdigit,	_ISupper|_ISxdigit,	_ISupper|_ISxdigit,
+	_ISupper|_ISxdigit,	_ISupper|_ISxdigit,	_ISupper|_ISxdigit,	_ISupper,
+/*110*/	_ISupper,		_ISupper,		_ISupper,		_ISupper,
+	_ISupper,		_ISupper,		_ISupper,		_ISupper,
+/*120*/	_ISupper,		_ISupper,		_ISupper,		_ISupper,
+	_ISupper,		_ISupper,		_ISupper,		_ISupper,
+/*130*/	_ISupper,		_ISupper,		_ISupper,		_ISpunct,
+	_ISpunct,		_ISpunct,		_ISpunct,		_ISpunct,
+/*140*/	_ISpunct,		_ISlower|_ISxdigit,	_ISlower|_ISxdigit,	_ISlower|_ISxdigit,
+	_ISlower|_ISxdigit,	_ISlower|_ISxdigit,	_ISlower|_ISxdigit,	_ISlower,
+/*150*/	_ISlower,		_ISlower,		_ISlower,		_ISlower,
+	_ISlower,		_ISlower,		_ISlower,		_ISlower,
+/*160*/	_ISlower,		_ISlower,		_ISlower,		_ISlower,
+	_ISlower,		_ISlower,		_ISlower,		_ISlower,
+/*170*/	_ISlower,		_ISlower,		_ISlower,		_ISpunct,
+	_ISpunct,		_ISpunct,		_ISpunct,		_IScntrl,
+/*200*/	 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,	 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,	 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,	 0,	 0,	 0,	 0,	 0,	 0,	 0,
+	 0,	 0,	 0,	 0,	 0,	 0,	 0,	 0,
+	 0,	 0,	 0,	 0,	 0,	 0,	 0,	 0
+};
diff --git a/sys/src/ape/lib/ap/gen/difftime.c b/sys/src/ape/lib/ap/gen/difftime.c
new file mode 100755
index 000000000..97ac3cee9
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/difftime.c
@@ -0,0 +1,9 @@
+#include <time.h>
+
+/* Difference in seconds between two calendar times */
+
+double
+difftime(time_t t1, time_t t0)
+{
+	return (double)t1-(double)t0;
+}
diff --git a/sys/src/ape/lib/ap/gen/div.c b/sys/src/ape/lib/ap/gen/div.c
new file mode 100755
index 000000000..10d92d97b
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/div.c
@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+div_t div(int numer, int denom)
+{
+	div_t ans;
+	ans.quot=numer/denom;  /* assumes division truncates */
+	ans.rem=numer-ans.quot*denom;
+	return ans;
+}
diff --git a/sys/src/ape/lib/ap/gen/getenv.c b/sys/src/ape/lib/ap/gen/getenv.c
new file mode 100755
index 000000000..e911d3298
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/getenv.c
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+
+extern	char **environ;
+
+char *
+getenv(const char *name)
+{
+	char **p = environ;
+	char *v, *s1, *s2;
+
+	while (*p != NULL){
+		for(s1 = (char *)name, s2 = *p++; *s1 == *s2; s1++, s2++)
+			continue;
+		if(*s1 == '\0' && *s2 == '=')
+			return s2+1;
+	}
+	return NULL ;
+}
diff --git a/sys/src/ape/lib/ap/gen/isalnum.c b/sys/src/ape/lib/ap/gen/isalnum.c
new file mode 100755
index 000000000..e1ab47cde
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/isalnum.c
@@ -0,0 +1,24 @@
+#include <ctype.h>
+
+#undef isalnum
+#undef isalpha
+#undef iscntrl
+#undef isdigit
+#undef isgraph
+#undef islower
+#undef isprint
+#undef ispunct
+#undef isspace
+#undef isupper
+#undef isxdigit
+int isalnum(int c){ return (_ctype+1)[c]&(_ISupper|_ISlower|_ISdigit); }
+int isalpha(int c){ return (_ctype+1)[c]&(_ISupper|_ISlower); }
+int iscntrl(int c){ return (_ctype+1)[c]&_IScntrl; }
+int isdigit(int c){ return (_ctype+1)[c]&_ISdigit; }
+int isgraph(int c){ return (_ctype+1)[c]&(_ISpunct|_ISupper|_ISlower|_ISdigit); }
+int islower(int c){ return (_ctype+1)[c]&_ISlower; }
+int isprint(int c){ return (_ctype+1)[c]&(_ISpunct|_ISupper|_ISlower|_ISdigit|_ISblank); }
+int ispunct(int c){ return (_ctype+1)[c]&_ISpunct; }
+int isspace(int c){ return (_ctype+1)[c]&_ISspace; }
+int isupper(int c){ return (_ctype+1)[c]&_ISupper; }
+int isxdigit(int c){ return (_ctype+1)[c]&_ISxdigit; }
diff --git a/sys/src/ape/lib/ap/gen/itoa.c b/sys/src/ape/lib/ap/gen/itoa.c
new file mode 100755
index 000000000..9e686556b
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/itoa.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+int
+itoa(const char *s)
+{
+	return(strtol(s, (char **)0, 10));
+}
diff --git a/sys/src/ape/lib/ap/gen/itol.c b/sys/src/ape/lib/ap/gen/itol.c
new file mode 100755
index 000000000..a618acc8a
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/itol.c
@@ -0,0 +1,7 @@
+#include	<stdlib.h>
+
+long
+itol(const char *s)
+{
+	return(strtol(s, (char **)0, 10));
+}
diff --git a/sys/src/ape/lib/ap/gen/ldiv.c b/sys/src/ape/lib/ap/gen/ldiv.c
new file mode 100755
index 000000000..01313e6ac
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/ldiv.c
@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+ldiv_t ldiv(long int numer, long int denom)
+{
+	ldiv_t ans;
+	ans.quot=numer/denom;
+	ans.rem=numer-ans.quot*denom;
+	return ans;
+}
diff --git a/sys/src/ape/lib/ap/gen/mbwc.c b/sys/src/ape/lib/ap/gen/mbwc.c
new file mode 100755
index 000000000..66a982193
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/mbwc.c
@@ -0,0 +1,165 @@
+#include <stdlib.h>
+
+/*
+ * Use the FSS-UTF transformation proposed by posix.
+ *	We define 7 byte types:
+ *	T0	0xxxxxxx	7 free bits
+ *	Tx	10xxxxxx	6 free bits
+ *	T1	110xxxxx	5 free bits
+ *	T2	1110xxxx	4 free bits
+ *
+ *	Encoding is as follows.
+ *	From hex	Thru hex	Sequence		Bits
+ *	00000000	0000007F	T0			7
+ *	00000080	000007FF	T1 Tx			11
+ *	00000800	0000FFFF	T2 Tx Tx		16
+ */
+
+int
+mblen(const char *s, size_t n)
+{
+
+	return mbtowc(0, s, n);
+}
+
+int
+mbtowc(wchar_t *pwc, const char *s, size_t n)
+{
+	int c, c1, c2;
+	long l;
+
+	if(!s)
+		return 0;
+
+	if(n < 1)
+		goto bad;
+	c = s[0] & 0xff;
+	if((c & 0x80) == 0x00) {
+		if(pwc)
+			*pwc = c;
+		if(c == 0)
+			return 0;
+		return 1;
+	}
+
+	if(n < 2)
+		goto bad;
+	c1 = (s[1] ^ 0x80) & 0xff;
+	if((c1 & 0xC0) != 0x00)
+		goto bad;
+	if((c & 0xE0) == 0xC0) {
+		l = ((c << 6) | c1) & 0x7FF;
+		if(l < 0x080)
+			goto bad;
+		if(pwc)
+			*pwc = l;
+		return 2;
+	}
+
+	if(n < 3)
+		goto bad;
+	c2 = (s[2] ^ 0x80) & 0xff;
+	if((c2 & 0xC0) != 0x00)
+		goto bad;
+	if((c & 0xF0) == 0xE0) {
+		l = ((((c << 6) | c1) << 6) | c2) & 0xFFFF;
+		if(l < 0x0800)
+			goto bad;
+		if(pwc)
+			*pwc = l;
+		return 3;
+	}
+
+	/*
+	 * bad decoding
+	 */
+bad:
+	return -1;
+
+}
+
+int
+wctomb(char *s, wchar_t wchar)
+{
+	long c;
+
+	if(!s)
+		return 0;
+
+	c = wchar & 0xFFFF;
+	if(c < 0x80) {
+		s[0] = c;
+		return 1;
+	}
+
+	if(c < 0x800) {
+		s[0] = 0xC0 | (c >> 6);
+		s[1] = 0x80 | (c & 0x3F);
+		return 2;
+	}
+
+	s[0] = 0xE0 |  (c >> 12);
+	s[1] = 0x80 | ((c >> 6) & 0x3F);
+	s[2] = 0x80 |  (c & 0x3F);
+	return 3;
+}
+
+size_t
+mbstowcs(wchar_t *pwcs, const char *s, size_t n)
+{
+	int i, d, c;
+
+	for(i=0; i < n; i++) {
+		c = *s & 0xff;
+		if(c < 0x80) {
+			*pwcs = c;
+			if(c == 0)
+				break;
+			s++;
+		} else {
+			d = mbtowc(pwcs, s, 3);
+			if(d <= 0)
+				return (size_t)((d<0) ? -1 : i);
+			s += d;
+		}
+		pwcs++;
+	}
+	return i;
+}
+
+size_t
+wcstombs(char *s, const wchar_t *pwcs, size_t n)
+{
+	int i, d;
+	long c;
+	char *p, *pe;
+	char buf[3];
+
+	p = s;
+	pe = p+n-3;
+	while(p < pe) {
+		c = *pwcs++;
+		if(c < 0x80)
+			*p++ = c;
+		else
+			p += wctomb(p, c);
+		if(c == 0)
+			return p-s;
+	}
+	while(p < pe+3) {
+		c = *pwcs++;
+		d = wctomb(buf, c);
+		if(p+d <= pe+3) {
+			*p++ = buf[0];
+			if(d > 1) {
+				*p++ = buf[2];
+				if(d > 2)
+					*p++ = buf[3];
+			}
+		}
+		if(c == 0)
+			break;
+	}
+	return p-s;
+}
+
diff --git a/sys/src/ape/lib/ap/gen/memccpy.c b/sys/src/ape/lib/ap/gen/memccpy.c
new file mode 100755
index 000000000..2f7b610d2
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/memccpy.c
@@ -0,0 +1,17 @@
+#include <string.h>
+
+void*
+memccpy(void *a1, void *a2, int c, size_t n)
+{
+	unsigned char *s1, *s2;
+
+	s1 = a1;
+	s2 = a2;
+	c &= 0xFF;
+	while(n > 0) {
+		if((*s1++ = *s2++) == c)
+			return s1;
+		n--;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/memchr.c b/sys/src/ape/lib/ap/gen/memchr.c
new file mode 100755
index 000000000..e63aefe8e
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/memchr.c
@@ -0,0 +1,16 @@
+#include	<string.h>
+
+void*
+memchr(const void *ap, int c, size_t n)
+{
+	unsigned char *sp;
+
+	sp = ap;
+	c &= 0xFF;
+	while(n > 0) {
+		if(*sp++ == c)
+			return sp-1;
+		n--;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/memcmp.c b/sys/src/ape/lib/ap/gen/memcmp.c
new file mode 100755
index 000000000..c07fbd0e9
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/memcmp.c
@@ -0,0 +1,22 @@
+#include	<string.h>
+
+int
+memcmp(const void *a1, const void *a2, size_t n)
+{
+	char *s1, *s2;
+	unsigned c1, c2;
+
+	s1 = a1;
+	s2 = a2;
+	while(n > 0) {
+		c1 = *s1++;
+		c2 = *s2++;
+		if(c1 != c2) {
+			if(c1 > c2)
+				return 1;
+			return -1;
+		}
+		n--;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/memmove.c b/sys/src/ape/lib/ap/gen/memmove.c
new file mode 100755
index 000000000..7eec93f68
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/memmove.c
@@ -0,0 +1,35 @@
+#include <string.h>
+
+void*
+memmove(void *a1, const void *a2, size_t n)
+{
+	char *s1, *s2;
+	extern void abort(void);
+
+	if((long)n < 0)
+		abort();
+	if(a1 > a2)
+		goto back;
+	s1 = a1;
+	s2 = a2;
+	while(n > 0) {
+		*s1++ = *s2++;
+		n--;
+	}
+	return a1;
+
+back:
+	s1 = (char*)a1 + n;
+	s2 = (char*)a2 + n;
+	while(n > 0) {
+		*--s1 = *--s2;
+		n--;
+	}
+	return a1;
+}
+
+void*
+memcpy(void *a1, const void *a2, size_t n)
+{
+	return memmove(a1, a2, n);
+}
diff --git a/sys/src/ape/lib/ap/gen/memset.c b/sys/src/ape/lib/ap/gen/memset.c
new file mode 100755
index 000000000..902874412
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/memset.c
@@ -0,0 +1,14 @@
+#include <string.h>
+
+void*
+memset(void *ap, int c, size_t n)
+{
+	char *p;
+
+	p = ap;
+	while(n > 0) {
+		*p++ = c;
+		n--;
+	}
+	return ap;
+}
diff --git a/sys/src/ape/lib/ap/gen/mkfile b/sys/src/ape/lib/ap/gen/mkfile
new file mode 100755
index 000000000..e9653bba1
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/mkfile
@@ -0,0 +1,63 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+
+ALLOFILES=\
+	_assert.$O\
+	abort.$O\
+	abs.$O\
+	atof.$O\
+	atoi.$O\
+	atol.$O\
+	atoll.$O\
+	bsearch.$O\
+	calloc.$O\
+	clock.$O\
+	ctype.$O\
+	difftime.$O\
+	div.$O\
+	getenv.$O\
+	isalnum.$O\
+	itoa.$O\
+	itol.$O\
+	ldiv.$O\
+	mbwc.$O\
+	memccpy.$O\
+	memchr.$O\
+	memcmp.$O\
+	memmove.$O\
+	memset.$O\
+	mktime.$O\
+	qsort.$O\
+	raise.$O\
+	rand.$O\
+	strcat.$O\
+	strchr.$O\
+	strcmp.$O\
+	strcoll.$O\
+	strcpy.$O\
+	strcspn.$O\
+	strftime.$O\
+	strlen.$O\
+	strncat.$O\
+	strncmp.$O\
+	strncpy.$O\
+	strpbrk.$O\
+	strrchr.$O\
+	strspn.$O\
+	strstr.$O\
+	strtod.$O\
+	strtok.$O\
+	strtol.$O\
+	strtoll.$O\
+	strtoul.$O\
+	strtoull.$O\
+	strxfrm.$O\
+	toupper.$O\
+
+# cull things in the per-machine directories from this list
+OFILES=	`{rc ./reduce $O $objtype $ALLOFILES}
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE
diff --git a/sys/src/ape/lib/ap/gen/mktime.c b/sys/src/ape/lib/ap/gen/mktime.c
new file mode 100755
index 000000000..2c8fa79fa
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/mktime.c
@@ -0,0 +1,122 @@
+#include <time.h>
+
+/*
+ * BUG: Doesn't do leap years in full glory,
+ * or calendar changes. In 2038 the sign bit
+ * will be needed in time_t, but we say it
+ * can't be represented.
+ */
+static int
+dysize(int y)
+{
+	y += 1900; /* arg is a tm_year, number of years since 1900 */
+	if((y%4) == 0 && ((y%100) !=0 || (y%400) == 0))
+		return 366;
+	return 365;
+}
+
+static int
+dmsize(int m, int y)
+{
+	static	char	sizes[12] =
+		{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+	if(m == 1)
+		return (dysize(y)==366)? 29 : 28;
+	else
+		return sizes[m];
+}
+
+/* Reduce *v to [0, mult), adding 1 to *next for every mult
+ * subtracted from *v, and return 1 if reduction worked (no overflow)
+ */
+static int
+reduce(int *v, int *next, int mult)
+{
+	int oldnext;
+
+	while(*v < 0){
+		*v += mult;
+		oldnext = *next;
+		--*next;
+		if(!(*next < oldnext))
+			return 0;
+	}
+	while(*v >= mult){
+		*v -= mult;
+		oldnext = *next;
+		++*next;
+		if(!(*next > oldnext))
+			return 0;
+	}
+	return 1;
+}
+
+static int
+jan1(int yr)
+{
+	int y, d;
+
+	y = yr+1900;
+	d = (4+y+(y+3)/4-(y-1701)/100+(y-1601)/400+3)%7;
+	return d;
+}
+
+time_t
+mktime(struct tm *t)
+{
+	time_t a;
+	int i, d;
+	struct tm *ptm;
+
+	if(!(reduce(&t->tm_sec, &t->tm_min, 60) &&
+	     reduce(&t->tm_min, &t->tm_hour, 60) &&
+	     reduce(&t->tm_hour, &t->tm_mday, 24) &&
+	     reduce(&t->tm_mon, &t->tm_year, 12)))
+		return -1;
+	while(t->tm_mday < 1){
+		if(--t->tm_mon == -1){
+			t->tm_mon = 11;
+			t->tm_year--;
+		}
+		t->tm_mday += dmsize(t->tm_mon, t->tm_year);
+	}
+	while(t->tm_mday > dmsize(t->tm_mon, t->tm_year)){
+		t->tm_mday -= dmsize(t->tm_mon, t->tm_year);
+		if(++t->tm_mon == 12){
+			t->tm_mon = 0;
+			t->tm_year++;
+		}
+	}
+	a = t->tm_sec + 60*t->tm_min + 3600*t->tm_hour;
+	t->tm_yday = t->tm_mday-1;
+	for(i=0; i<t->tm_mon; i++)
+		t->tm_yday += dmsize(i, t->tm_year);
+	a += t->tm_yday*86400L;
+	if(t->tm_year < 70){
+		for(i=t->tm_year; i<70; i++)
+			if((a -= dysize(i)*86400L) < 0)
+				return -1;
+	}else if(t->tm_year > 70){
+		for(i=70; i<t->tm_year; i++)
+			if((a += dysize(i)*86400L) < 0)
+				return -1;
+	}
+	/*
+	 * Now a is number of seconds past Jan 1 1970.
+	 * Convert to GMT.
+	 */
+	ptm = gmtime(&a);
+	d = ptm->tm_hour;
+	ptm = localtime(&a);
+	d -= ptm->tm_hour;
+	if(d < 0)
+		d += 24;
+	if(t->tm_isdst == 0 && ptm->tm_isdst)
+		d--;
+	if(t->tm_isdst > 0 && !ptm->tm_isdst)
+		d++;
+	a += d*3600;
+	t->tm_wday = (jan1(t->tm_year)+t->tm_yday)%7;
+	return a;
+}
diff --git a/sys/src/ape/lib/ap/gen/qsort.c b/sys/src/ape/lib/ap/gen/qsort.c
new file mode 100755
index 000000000..e3fb9d12f
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/qsort.c
@@ -0,0 +1,90 @@
+/* qsort -- qsort interface implemented by faster quicksort */
+#include <stdlib.h>
+
+#define SWAPINIT(a, es) swaptype =                            \
+    (a - (char*) 0) % sizeof(long) || es % sizeof(long) ? 2 : \
+    es == sizeof(long) ? 0 : 1;
+#define swapcode(TYPE, parmi, parmj, n) {  \
+    long i = (n) / (int) sizeof(TYPE);     \
+    register TYPE *pi = (TYPE *) (parmi);  \
+    register TYPE *pj = (TYPE *) (parmj);  \
+    do {                                   \
+        register TYPE t = *pi;             \
+        *pi++ = *pj;                       \
+        *pj++ = t;                         \
+    } while (--i > 0);                     \
+}
+static void swapfunc(char *a, char *b, int n, int swaptype)
+{   if (swaptype <= 1) swapcode(long, a, b, n)
+    else swapcode(char, a, b, n)
+}
+#define swap(a, b) {                       \
+    if (swaptype == 0) {                   \
+        long t = * (long *) (a);           \
+        * (long *) (a) = * (long *) (b);   \
+        * (long *) (b) = t;                \
+    } else                                 \
+        swapfunc(a, b, es, swaptype);      \
+}
+#define vecswap(a, b, n) { if (n > 0) swapfunc(a, b, n*es, swaptype); }
+
+static char *med3func(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
+{	return cmp(a, b) < 0 ?
+		  (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ) )
+		: (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ) );
+}
+#define med3(a, b, c) med3func(a, b, c, cmp)
+
+void qsort(void *va, size_t n, size_t es, int (*cmp)(const void *, const void *))
+{
+	char *a, *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+	int  r, swaptype, na, nb, nc, nd, d;
+
+	a = va;
+	SWAPINIT(a, es);
+	if (n < 7) { /* Insertion sort on small arrays */
+		for (pm = a + es; pm < a + n*es; pm += es)
+			for (pl = pm; pl > a && cmp(pl-es, pl) > 0; pl -= es)
+				swap(pl, pl-es);
+		return;
+	}
+	pm = a + (n/2) * es;
+	if (n > 7) {
+		pl = a;
+		pn = a + (n-1) * es;
+		if (n > 40) { /* On big arrays, pseudomedian of 9 */
+			d = (n/8) * es;
+			pl = med3(pl, pl+d, pl+2*d);
+			pm = med3(pm-d, pm, pm+d);
+			pn = med3(pn-2*d, pn-d, pn);
+		}
+		pm = med3(pl, pm, pn); /* On medium arrays, median of 3 */
+	}
+	swap(a, pm); /* On tiny arrays, partition around middle */
+	pa = pb = a + es;
+	pc = pd = pn = a + (n-1)*es;
+	for (;;) {
+		while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+			if (r == 0) { swap(pa, pb); pa += es; }
+			pb += es;
+		}
+		while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+			if (r == 0) { swap(pc, pd); pd -= es; }
+			pc -= es;
+		}
+		if (pb > pc) break;
+		swap(pb, pc);
+		pb += es;
+		pc -= es;
+	}
+	na = (pa - a)  / es;
+	nb = (pb - pa) / es;
+	nc = (pd - pc) / es;
+	nd = (pn - pd) / es;
+	if (na < nb) { vecswap(a,  a + nb*es,  na); }
+	else	     { vecswap(a,  a + na*es,  nb); }
+	if (nc < nd) { vecswap(pb, pb + nd*es, nc); }
+	else	     { vecswap(pb, pb + nc*es, nd); }
+	if (nb > 1) qsort(a, nb, es, cmp);
+	if (nc > 1) qsort(a + (n-nc) * es, nc, es, cmp);
+}
diff --git a/sys/src/ape/lib/ap/gen/raise.c b/sys/src/ape/lib/ap/gen/raise.c
new file mode 100755
index 000000000..f93b20d3a
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/raise.c
@@ -0,0 +1,11 @@
+/* not a posix function, but implemented with posix kill, getpid */
+
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+
+int
+raise(int sig)
+{
+	return kill(getpid(), sig);
+}
diff --git a/sys/src/ape/lib/ap/gen/rand.c b/sys/src/ape/lib/ap/gen/rand.c
new file mode 100755
index 000000000..c73ad826c
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/rand.c
@@ -0,0 +1,75 @@
+#include	<stdlib.h>
+
+/*
+ *	algorithm by
+ *	D. P. Mitchell & J. A. Reeds
+ */
+#define	LEN	607
+#define	TAP	273
+#define	MASK	0x7fffffffL
+#define	A	48271
+#define	M	2147483647
+#define	Q	44488
+#define	R	3399
+
+typedef unsigned long	ulong;
+
+static	ulong	rng_vec[LEN];
+static	ulong*	rng_tap = rng_vec;
+static	ulong*	rng_feed = 0;
+
+void
+srand(unsigned int seed)
+{
+	long lo, hi, x;
+	int i;
+
+	rng_tap = rng_vec;
+	rng_feed = rng_vec+LEN-TAP;
+	seed = seed%M;
+	if(seed < 0)
+		seed += M;
+	if(seed == 0)
+		seed = 89482311;
+	x = seed;
+	/*
+	 *	Initialize by x[n+1] = 48271 * x[n] mod (2**31 - 1)
+	 */
+	for(i = -20; i < LEN; i++) {
+		hi = x / Q;
+		lo = x % Q;
+		x = A*lo - R*hi;
+		if(x < 0)
+			x += M;
+		if(i >= 0)
+			rng_vec[i] = x;
+	}
+}
+
+static long
+lrand(void)
+{
+	ulong x;
+
+	rng_tap--;
+        if(rng_tap < rng_vec) {
+                if(rng_feed == 0) {
+			srand(1);
+			rng_tap--;
+		}
+                rng_tap += LEN;
+        }
+	rng_feed--;
+        if(rng_feed < rng_vec)
+                rng_feed += LEN;
+	x = (*rng_feed + *rng_tap) & MASK;
+	*rng_feed = x;
+        return x;
+}
+
+int
+rand(void)
+{
+
+	return lrand() & 0x7fff;
+}
diff --git a/sys/src/ape/lib/ap/gen/reduce b/sys/src/ape/lib/ap/gen/reduce
new file mode 100755
index 000000000..584f8b9ab
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/reduce
@@ -0,0 +1,16 @@
+O=$1
+shift
+objtype=$1
+shift
+
+ls -p ../$objtype/*.[cs] >[2]/dev/null | sed 's/..$//;s/^/^/' > /tmp/reduce.$pid
+#
+#	if empty directory, just return the input files
+#
+if (! ~ $status '|') {
+	echo $*
+	rm /tmp/reduce.$pid
+	exit 0
+}
+echo $* | tr ' ' \012 | grep -v -f /tmp/reduce.$pid | tr \012 ' '
+rm /tmp/reduce.$pid
diff --git a/sys/src/ape/lib/ap/gen/strcat.c b/sys/src/ape/lib/ap/gen/strcat.c
new file mode 100755
index 000000000..6aa75d109
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strcat.c
@@ -0,0 +1,9 @@
+#include <string.h>
+
+char*
+strcat(char *s1, const char *s2)
+{
+
+	strcpy(strchr(s1, 0), s2);
+	return s1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strchr.c b/sys/src/ape/lib/ap/gen/strchr.c
new file mode 100755
index 000000000..b6d935f57
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strchr.c
@@ -0,0 +1,18 @@
+#include <string.h>
+
+char*
+strchr(const char *s, int c)
+{
+	char c1;
+
+	if(c == 0) {
+		while(*s++)
+			;
+		return s-1;
+	}
+
+	while(c1 = *s++)
+		if(c1 == c)
+			return s-1;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/strcmp.c b/sys/src/ape/lib/ap/gen/strcmp.c
new file mode 100755
index 000000000..a9b4827e7
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strcmp.c
@@ -0,0 +1,19 @@
+#include <string.h>
+
+int
+strcmp(const char *s1, const char *s2)
+{
+	unsigned c1, c2;
+
+	for(;;) {
+		c1 = *s1++;
+		c2 = *s2++;
+		if(c1 != c2) {
+			if(c1 > c2)
+				return 1;
+			return -1;
+		}
+		if(c1 == 0)
+			return 0;
+	}
+}
diff --git a/sys/src/ape/lib/ap/gen/strcoll.c b/sys/src/ape/lib/ap/gen/strcoll.c
new file mode 100755
index 000000000..fda140945
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strcoll.c
@@ -0,0 +1,8 @@
+#include <string.h>
+
+int
+strcoll(const char *s1, const char *s2)
+{
+	/* BUG: supposed to pay attention to LC_COLLATE of current locale */
+	return strcmp(s1, s2);
+}
diff --git a/sys/src/ape/lib/ap/gen/strcpy.c b/sys/src/ape/lib/ap/gen/strcpy.c
new file mode 100755
index 000000000..6a294eee5
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strcpy.c
@@ -0,0 +1,30 @@
+#include <string.h>
+#define	N	10000
+
+static void*
+memccpy(void *a1, void *a2, int c, unsigned long n)
+{
+	char *s1, *s2;
+
+	s1 = a1;
+	s2 = a2;
+	while(n > 0) {
+		if((*s1++ = *s2++) == c)
+			return s1;
+		n--;
+	}
+	return 0;
+}
+
+char*
+strcpy(char *s1, const char *s2)
+{
+	char *os1;
+
+	os1 = s1;
+	while(!memccpy(s1, s2, 0, N)) {
+		s1 += N;
+		s2 += N;
+	}
+	return os1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strcspn.c b/sys/src/ape/lib/ap/gen/strcspn.c
new file mode 100755
index 000000000..f7628e8ae
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strcspn.c
@@ -0,0 +1,20 @@
+#include <string.h>
+
+#define	N	256
+
+size_t
+strcspn(const char *s, const char *b)
+{
+	char map[N], *os;
+
+	memset(map, 0, N);
+	for(;;) {
+		map[*(unsigned char*)b] = 1;
+		if(*b++ == 0)
+			break;
+	}
+	os = s;
+	while(map[*(unsigned char*)s++] == 0)
+		;
+	return s - os - 1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strftime.c b/sys/src/ape/lib/ap/gen/strftime.c
new file mode 100755
index 000000000..f86606089
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strftime.c
@@ -0,0 +1,202 @@
+#include <time.h>
+#include <string.h>
+
+static char *awday[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+static char *wday[7] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+			"Friday", "Saturday"};
+static char *amon[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+			    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+static char *mon[12] = {"January", "February", "March", "April", "May", "June",
+		"July", "August", "September", "October", "November", "December"};
+static char *ampm[2] = {"AM", "PM"};
+static char *tz[2] = {"EST", "EDT"};
+
+static int jan1(int);
+static char *strval(char *, char *, char **, int, int);
+static char *dval(char *, char *, int, int);
+
+size_t
+strftime(char *s, size_t maxsize, const char *format, const struct tm *t)
+{
+	char *sp, *se, *fp;
+	int i;
+
+	sp = s;
+	se = s+maxsize;
+	for(fp=(char *)format; *fp && sp<se; fp++){
+		if(*fp != '%')
+			*sp++ = *fp;
+		else switch(*++fp){
+			case 'a':
+				sp = strval(sp, se, awday, t->tm_wday, 7);
+				break;
+			case 'A':
+				sp = strval(sp, se, wday, t->tm_wday, 7);
+				break;
+			case 'b':
+				sp = strval(sp, se, amon, t->tm_mon, 12);
+				break;
+			case 'B':
+				sp = strval(sp, se, mon, t->tm_mon, 12);
+				break;
+			case 'c':
+				sp += strftime(sp, se-sp, "%a %b %d %H:%M:%S %Y", t);
+				break;
+			case 'd':
+				sp = dval(sp, se, t->tm_mday, 2);
+				break;
+			case 'H':
+				sp = dval(sp, se, t->tm_hour, 2);
+				break;
+			case 'I':
+				i = t->tm_hour;
+				if(i == 0)
+					i = 12;
+				else if(i > 12)
+					i -= 12;
+				sp = dval(sp, se, i, 2);
+				break;
+			case 'j':
+				sp = dval(sp, se, t->tm_yday+1, 3);
+				break;
+			case 'm':
+				sp = dval(sp, se, t->tm_mon+1, 2);
+				break;
+			case 'M':
+				sp = dval(sp, se, t->tm_min, 2);
+				break;
+			case 'p':
+				i = (t->tm_hour < 12)? 0 : 1;
+				sp = strval(sp, se, ampm, i, 2);
+				break;
+			case 'S':
+				sp = dval(sp, se, t->tm_sec, 2);
+				break;
+			case 'U':
+				i = 7-jan1(t->tm_year);
+				if(i == 7)
+					i = 0;
+				/* Now i is yday number of first sunday in year */
+				if(t->tm_yday < i)
+					i = 0;
+				else
+					i = (t->tm_yday-i)/7 + 1;
+				sp = dval(sp, se, i, 2);
+				break;
+			case 'w':
+				sp = dval(sp, se, t->tm_wday, 1);
+				break;
+			case 'W':
+				i = 8-jan1(t->tm_year);
+				if(i >= 7)
+					i -= 7;
+				/* Now i is yday number of first monday in year */
+				if(t->tm_yday < i)
+					i = 0;
+				else
+					i = (t->tm_yday-i)/7 + 1;
+				sp = dval(sp, se, i, 2);
+				break;
+			case 'x':
+				sp += strftime(sp, se-sp, "%a %b %d, %Y", t);
+				break;
+			case 'X':
+				sp += strftime(sp, se-sp, "%H:%M:%S", t);
+				break;
+			case 'y':
+				sp = dval(sp, se, t->tm_year%100, 2);
+				break;
+			case 'Y':
+				sp = dval(sp, se, t->tm_year+1900, 4);
+				break;
+			case 'Z':
+				/* hack for now: assume eastern time zone */
+				i = t->tm_isdst? 1 : 0;
+				sp = strval(sp, se, tz, i, 2);
+				break;
+			case 0:
+				fp--; /* stop loop after next fp incr */
+				break;
+			default:
+				*sp++ = *fp;
+			}
+	}
+	if(*fp)
+		sp = s; /* format string didn't end: no room for conversion */
+	if(sp<se)
+		*sp = 0;
+	return sp-s;
+}
+
+static char *
+strval(char *start, char *end, char **array, int index, int alen)
+{
+	int n;
+
+	if(index<0 || index>=alen){
+		*start = '?';
+		return start+1;
+	}
+	n = strlen(array[index]);
+	if(n > end-start)
+		n = end-start;
+	memcpy(start, array[index], n);
+	return start+n;
+}
+
+static char *
+dval(char *start, char *end, int val, int width)
+{
+	char *p;
+
+	if(val<0 || end-start<width){
+		*start = '?';
+		return start+1;
+	}
+	p = start+width-1;
+	while(p>=start){
+		*p-- = val%10 + '0';
+		val /= 10;
+	}
+	if(val>0)
+		*start = '*';
+	return start+width;
+}
+
+/*
+ *	return day of the week
+ *	of jan 1 of given year
+ */
+static int
+jan1(int yr)
+{
+	int y, d;
+
+/*
+ *	normal gregorian calendar
+ *	one extra day per four years
+ */
+
+	y = yr+1900;
+	d = 4+y+(y+3)/4;
+
+/*
+ *	julian calendar
+ *	regular gregorian
+ *	less three days per 400
+ */
+
+	if(y > 1800) {
+		d -= (y-1701)/100;
+		d += (y-1601)/400;
+	}
+
+/*
+ *	great calendar changeover instant
+ */
+
+	if(y > 1752)
+		d += 3;
+
+	return(d%7);
+}
diff --git a/sys/src/ape/lib/ap/gen/strlen.c b/sys/src/ape/lib/ap/gen/strlen.c
new file mode 100755
index 000000000..e339cb16b
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strlen.c
@@ -0,0 +1,8 @@
+#include <string.h>
+
+size_t
+strlen(const char *s)
+{
+
+	return strchr(s, 0) - s;
+}
diff --git a/sys/src/ape/lib/ap/gen/strncat.c b/sys/src/ape/lib/ap/gen/strncat.c
new file mode 100755
index 000000000..8891724b4
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strncat.c
@@ -0,0 +1,20 @@
+#include <string.h>
+
+char*
+strncat(char *s1, const char *s2, size_t n)
+{
+	char *os1;
+	long nn;
+
+	os1 = s1;
+	nn = n;
+	while(*s1++)
+		;
+	s1--;
+	while(*s1++ = *s2++)
+		if(--nn < 0) {
+			s1[-1] = 0;
+			break;
+		}
+	return os1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strncmp.c b/sys/src/ape/lib/ap/gen/strncmp.c
new file mode 100755
index 000000000..e76b09b9d
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strncmp.c
@@ -0,0 +1,23 @@
+#include <string.h>
+
+int
+strncmp(const char *s1, const char *s2, size_t n)
+{
+	unsigned c1, c2;
+	long nn;
+
+	nn = n;
+	while(nn > 0) {
+		c1 = *s1++;
+		c2 = *s2++;
+		nn--;
+		if(c1 != c2) {
+			if(c1 > c2)
+				return 1;
+			return -1;
+		}
+		if(c1 == 0)
+			break;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/strncpy.c b/sys/src/ape/lib/ap/gen/strncpy.c
new file mode 100755
index 000000000..28a5a522c
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strncpy.c
@@ -0,0 +1,17 @@
+#include <string.h>
+
+char*
+strncpy(char *s1, const char *s2, size_t n)
+{
+	int i;
+	char *os1;
+
+	os1 = s1;
+	for(i = 0; i < n; i++)
+		if((*s1++ = *s2++) == 0) {
+			while(++i < n)
+				*s1++ = 0;
+			return os1;
+		}
+	return os1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strpbrk.c b/sys/src/ape/lib/ap/gen/strpbrk.c
new file mode 100755
index 000000000..407f1c266
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strpbrk.c
@@ -0,0 +1,20 @@
+#include <string.h>
+#define	N	256
+
+char*
+strpbrk(const char *s, const char *b)
+{
+	char map[N];
+
+	memset(map, 0, N);
+	for(;;) {
+		map[*b] = 1;
+		if(*b++ == 0)
+			break;
+	}
+	while(map[*s++] == 0)
+		;
+	if(*--s)
+		return s;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/gen/strrchr.c b/sys/src/ape/lib/ap/gen/strrchr.c
new file mode 100755
index 000000000..038b06ad2
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strrchr.c
@@ -0,0 +1,14 @@
+#include <string.h>
+
+char*
+strrchr(const char *s, int c)
+{
+	char *r;
+
+	if(c == 0)
+		return strchr(s, 0);
+	r = 0;
+	while(s = strchr(s, c))
+		r = s++;
+	return r;
+}
diff --git a/sys/src/ape/lib/ap/gen/strspn.c b/sys/src/ape/lib/ap/gen/strspn.c
new file mode 100755
index 000000000..57ebfd1b5
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strspn.c
@@ -0,0 +1,17 @@
+#include <string.h>
+
+#define	N	256
+
+size_t
+strspn(const char *s, const char *b)
+{
+	char map[N], *os;
+
+	memset(map, 0, N);
+	while(*b)
+		map[*(unsigned char *)b++] = 1;
+	os = s;
+	while(map[*(unsigned char *)s++])
+		;
+	return s - os - 1;
+}
diff --git a/sys/src/ape/lib/ap/gen/strstr.c b/sys/src/ape/lib/ap/gen/strstr.c
new file mode 100755
index 000000000..4e6828571
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strstr.c
@@ -0,0 +1,27 @@
+#include <string.h>
+
+/* Return pointer to first occurrence of s2 in s1, NULL if none */
+
+char
+*strstr(const char *s1, const char *s2)
+{
+	char *p, *pa, *pb;
+	int c0, c;
+
+	c0 = *s2;
+	if(c0 == 0)
+		return s1;
+	s2++;
+	for(p=strchr(s1, c0); p; p=strchr(p+1, c0)) {
+		pa = p;
+		for(pb=s2;; pb++) {
+			c = *pb;
+			if(c == 0)
+				return p;
+			if(c != *++pa)
+				break;
+		}
+	}
+	return 0;
+}
+
diff --git a/sys/src/ape/lib/ap/gen/strtod.c b/sys/src/ape/lib/ap/gen/strtod.c
new file mode 100755
index 000000000..ca4939100
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtod.c
@@ -0,0 +1,91 @@
+#include <math.h>
+#include <errno.h>
+
+/*
+ * bug: should detect overflow, set errno = ERANGE, and return +/- HUGE_VAL
+ */
+double
+strtod(const char *cp, char **endptr)
+{
+	double num, dem;
+	extern double pow10(int);
+	int neg, eneg, dig, predig, exp, c;
+	const char *p;
+
+	p = cp;
+	num = 0;
+	neg = 0;
+	dig = 0;
+	predig = 0;
+	exp = 0;
+	eneg = 0;
+
+	c = *p++;
+	while(c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\v' || c == '\r')
+		c = *p++;
+	if(c == '-' || c == '+'){
+		if(c == '-')
+			neg = 1;
+		c = *p++;
+	}
+	while(c >= '0' && c <= '9'){
+		num = num*10 + c-'0';
+		predig++;
+		c = *p++;
+	}
+	if(c == '.')
+		c = *p++;
+	while(c >= '0' && c <= '9'){
+		num = num*10 + c-'0';
+		dig++;
+		c = *p++;
+	}
+	if(dig+predig == 0){
+		if(endptr)
+			*endptr = (char *)cp;
+		return 0.0;
+	}
+	if(c == 'e' || c == 'E'){
+		c = *p++;
+		if(c == '-' || c == '+'){
+			if(c == '-'){
+				dig = -dig;
+				eneg = 1;
+			}
+			c = *p++;
+		}
+		while(c >= '0' && c <= '9'){
+			exp = exp*10 + c-'0';
+			c = *p++;
+		}
+	}
+	exp -= dig;
+	if(exp < 0){
+		exp = -exp;
+		eneg = !eneg;
+	}
+	dem = pow10(exp);
+	if(dem==HUGE_VAL)
+		num = eneg? 0.0 : HUGE_VAL;
+	else if(dem==0)
+		num = eneg? HUGE_VAL : 0.0;
+	else if(eneg)
+		num /= dem;
+	else
+		num *= dem;
+	if(neg)
+		num = -num;
+	if(endptr){
+		*endptr = (char *)--p;
+		/*
+		 * Fix cases like 2.3e+
+		 */
+		while(p > cp){
+			c = *--p;
+			if(c!='-' && c!='+' && c!='e' && c!='E')
+				break;
+			(*endptr)--;
+		}
+	}
+	return num;
+}
diff --git a/sys/src/ape/lib/ap/gen/strtok.c b/sys/src/ape/lib/ap/gen/strtok.c
new file mode 100755
index 000000000..24155782a
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtok.c
@@ -0,0 +1,36 @@
+#include <string.h>
+
+#define	N	256
+
+char*
+strtok_r(char *s, const char *b, char **last)
+{
+	char map[N], *os;
+
+	memset(map, 0, N);
+	while(*b)
+		map[*(unsigned char*)b++] = 1;
+	if(s == 0)
+		s = *last;
+	while(map[*(unsigned char*)s++])
+		;
+	if(*--s == 0)
+		return 0;
+	os = s;
+	while(map[*(unsigned char*)s] == 0)
+		if(*s++ == 0) {
+			*last = s-1;
+			return os;
+		}
+	*s++ = 0;
+	*last = s;
+	return os;
+}
+
+char*
+strtok(char *s, const char *b)
+{
+	static char *under_rock;
+
+	return strtok_r(s, b, &under_rock);
+}
diff --git a/sys/src/ape/lib/ap/gen/strtol.c b/sys/src/ape/lib/ap/gen/strtol.c
new file mode 100755
index 000000000..1c5d99632
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtol.c
@@ -0,0 +1,94 @@
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+
+long
+strtol(const char *nptr, char **endptr, int base)
+{
+	const char *p;
+	long n, nn;
+	int c, ovfl, v, neg, ndig;
+
+	p = nptr;
+	neg = 0;
+	n = 0;
+	ndig = 0;
+	ovfl = 0;
+
+	/*
+	 * White space
+	 */
+	for(;;p++){
+		switch(*p){
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\f':
+		case '\r':
+		case '\v':
+			continue;
+		}
+		break;
+	}
+
+	/*
+	 * Sign
+	 */
+	if(*p=='-' || *p=='+')
+		if(*p++ == '-')
+			neg = 1;
+
+	/*
+	 * Base
+	 */
+	if(base==0){
+		if(*p != '0')
+			base = 10;
+		else{
+			base = 8;
+			if(p[1]=='x' || p[1]=='X'){
+				p += 2;
+				base = 16;
+			}
+		}
+	}else if(base==16 && *p=='0'){
+		if(p[1]=='x' || p[1]=='X')
+			p += 2;
+	}else if(base<0 || 36<base)
+		goto Return;
+
+	/*
+	 * Non-empty sequence of digits
+	 */
+	for(;; p++,ndig++){
+		c = *p;
+		v = base;
+		if('0'<=c && c<='9')
+			v = c - '0';
+		else if('a'<=c && c<='z')
+			v = c - 'a' + 10;
+		else if('A'<=c && c<='Z')
+			v = c - 'A' + 10;
+		if(v >= base)
+			break;
+		nn = n*base + v;
+		if(nn < n)
+			ovfl = 1;
+		n = nn;
+	}
+
+    Return:
+	if(ndig == 0)
+		p = nptr;
+	if(endptr)
+		*endptr = (char *)p;
+	if(ovfl){
+		errno = ERANGE;
+		if(neg)
+			return LONG_MIN;
+		return LONG_MAX;
+	}
+	if(neg)
+		return -n;
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/gen/strtoll.c b/sys/src/ape/lib/ap/gen/strtoll.c
new file mode 100755
index 000000000..e633d2d08
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtoll.c
@@ -0,0 +1,103 @@
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+
+#define VLONG_MAX	~(1LL<<63)
+#define VLONG_MIN	(1LL<<63)
+
+long long
+strtoll(char *nptr, char **endptr, int base)
+{
+	char *p;
+	long long n, nn, m;
+	int c, ovfl, v, neg, ndig;
+
+	p = nptr;
+	neg = 0;
+	n = 0;
+	ndig = 0;
+	ovfl = 0;
+
+	/*
+	 * White space
+	 */
+	for(;; p++) {
+		switch(*p) {
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\f':
+		case '\r':
+		case '\v':
+			continue;
+		}
+		break;
+	}
+
+	/*
+	 * Sign
+	 */
+	if(*p=='-' || *p=='+')
+		if(*p++ == '-')
+			neg = 1;
+
+	/*
+	 * Base
+	 */
+	if(base==0){
+		base = 10;
+		if(*p == '0') {
+			base = 8;
+			if(p[1]=='x' || p[1]=='X') {
+				p += 2;
+				base = 16;
+			}
+		}
+	} else
+	if(base==16 && *p=='0') {
+		if(p[1]=='x' || p[1]=='X')
+			p += 2;
+	} else
+	if(base<0 || 36<base)
+		goto Return;
+
+	/*
+	 * Non-empty sequence of digits
+	 */
+	m = VLONG_MAX/base;
+	for(;; p++,ndig++) {
+		c = *p;
+		v = base;
+		if('0'<=c && c<='9')
+			v = c - '0';
+		else
+		if('a'<=c && c<='z')
+			v = c - 'a' + 10;
+		else
+		if('A'<=c && c<='Z')
+			v = c - 'A' + 10;
+		if(v >= base)
+			break;
+		if(n > m)
+			ovfl = 1;
+		nn = n*base + v;
+		if(nn < n)
+			ovfl = 1;
+		n = nn;
+	}
+
+Return:
+	if(ndig == 0)
+		p = nptr;
+	if(endptr)
+		*endptr = p;
+	if(ovfl){
+		errno = ERANGE;
+		if(neg)
+			return VLONG_MIN;
+		return VLONG_MAX;
+	}
+	if(neg)
+		return -n;
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/gen/strtoul.c b/sys/src/ape/lib/ap/gen/strtoul.c
new file mode 100755
index 000000000..bb7dce7ae
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtoul.c
@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+
+unsigned long
+strtoul(const char *nptr, char **endptr, int base)
+{
+	const char *p;
+	unsigned long n, nn;
+	int c, ovfl, neg, v, ndig;
+
+	p = (char*)nptr;
+	neg = 0;
+	n = 0;
+	ndig = 0;
+	ovfl = 0;
+
+	/*
+	 * White space
+	 */
+	for(;;p++){
+		switch(*p){
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\f':
+		case '\r':
+		case '\v':
+			continue;
+		}
+		break;
+	}
+
+	/*
+	 * Sign
+	 */
+	if(*p=='-' || *p=='+')
+		if(*p++ == '-')
+			neg = 1;
+
+	/*
+	 * Base
+	 */
+	if(base==0){
+		if(*p != '0')
+			base = 10;
+		else{
+			base = 8;
+			if(p[1]=='x' || p[1]=='X'){
+				p += 2;
+				base = 16;
+			}
+		}
+	}else if(base==16 && *p=='0'){
+		if(p[1]=='x' || p[1]=='X')
+			p += 2;
+	}else if(base<0 || 36<base)
+		goto Return;
+
+	/*
+	 * Non-empty sequence of digits
+	 */
+	for(;; p++,ndig++){
+		c = *p;
+		v = base;
+		if('0'<=c && c<='9')
+			v = c - '0';
+		else if('a'<=c && c<='z')
+			v = c - 'a' + 10;
+		else if('A'<=c && c<='Z')
+			v = c - 'A' + 10;
+		if(v >= base)
+			break;
+		nn = n*base + v;
+		if(nn < n)
+			ovfl = 1;
+		n = nn;
+	}
+
+    Return:
+	if(ndig == 0)
+		p = nptr;
+	if(endptr)
+		*endptr = (char *)p;
+	if(ovfl){
+		errno = ERANGE;
+		return ULONG_MAX;
+	}
+	if(neg)
+		return -n;
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/gen/strtoull.c b/sys/src/ape/lib/ap/gen/strtoull.c
new file mode 100755
index 000000000..76aa392a4
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strtoull.c
@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+
+#define UVLONG_MAX	(1LL<<63)
+
+unsigned long long
+strtoull(char *nptr, char **endptr, int base)
+{
+	char *p;
+	unsigned long long n, nn, m;
+	int c, ovfl, v, neg, ndig;
+
+	p = nptr;
+	neg = 0;
+	n = 0;
+	ndig = 0;
+	ovfl = 0;
+
+	/*
+	 * White space
+	 */
+	for(;; p++) {
+		switch(*p) {
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\f':
+		case '\r':
+		case '\v':
+			continue;
+		}
+		break;
+	}
+
+	/*
+	 * Sign
+	 */
+	if(*p == '-' || *p == '+')
+		if(*p++ == '-')
+			neg = 1;
+
+	/*
+	 * Base
+	 */
+	if(base == 0) {
+		base = 10;
+		if(*p == '0') {
+			base = 8;
+			if(p[1] == 'x' || p[1] == 'X'){
+				p += 2;
+				base = 16;
+			}
+		}
+	} else
+	if(base == 16 && *p == '0') {
+		if(p[1] == 'x' || p[1] == 'X')
+			p += 2;
+	} else
+	if(base < 0 || 36 < base)
+		goto Return;
+
+	/*
+	 * Non-empty sequence of digits
+	 */
+	m = UVLONG_MAX/base;
+	for(;; p++,ndig++) {
+		c = *p;
+		v = base;
+		if('0' <= c && c <= '9')
+			v = c - '0';
+		else
+		if('a' <= c && c <= 'z')
+			v = c - 'a' + 10;
+		else
+		if('A' <= c && c <= 'Z')
+			v = c - 'A' + 10;
+		if(v >= base)
+			break;
+		if(n > m)
+			ovfl = 1;
+		nn = n*base + v;
+		if(nn < n)
+			ovfl = 1;
+		n = nn;
+	}
+
+Return:
+	if(ndig == 0)
+		p = nptr;
+	if(endptr)
+		*endptr = p;
+	if(ovfl){
+		errno = ERANGE;
+		return UVLONG_MAX;
+	}
+	if(neg)
+		return -n;
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/gen/strxfrm.c b/sys/src/ape/lib/ap/gen/strxfrm.c
new file mode 100755
index 000000000..ecb095064
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/strxfrm.c
@@ -0,0 +1,17 @@
+#include <string.h>
+
+size_t
+strxfrm(char *s1, const char *s2, size_t n)
+{
+	/*
+	 * BUG: supposed to transform s2 to a canonical form
+	 * so that strcmp can be used instead of strcoll, but
+	 * our strcoll just uses strcmp.
+	 */
+
+	size_t xn = strlen(s2);
+	if(n > xn)
+		n = xn;
+	memcpy(s1, s2, n);
+	return xn;
+}
diff --git a/sys/src/ape/lib/ap/gen/toupper.c b/sys/src/ape/lib/ap/gen/toupper.c
new file mode 100755
index 000000000..eb1e8efd5
--- /dev/null
+++ b/sys/src/ape/lib/ap/gen/toupper.c
@@ -0,0 +1,17 @@
+#include	<ctype.h>
+
+toupper(int c)
+{
+
+	if(c < 'a' || c > 'z')
+		return c;
+	return (c-'a'+'A');
+}
+
+tolower(int c)
+{
+
+	if(c < 'A' || c > 'Z')
+		return c;
+	return (c-'A'+'a');
+}
diff --git a/sys/src/ape/lib/ap/math/asin.c b/sys/src/ape/lib/ap/math/asin.c
new file mode 100755
index 000000000..efd3a8cc8
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/asin.c
@@ -0,0 +1,47 @@
+/*
+	asin(arg) and acos(arg) return the arcsin, arccos,
+	respectively of their arguments.
+
+	Arctan is called after appropriate range reduction.
+ */
+
+#include <math.h>
+#include <errno.h>
+
+static double pio2	= 1.570796326794896619231e0;
+
+double
+asin(double arg)
+{
+	double temp;
+	int sign;
+
+	sign = 0;
+	if(arg < 0) {
+		arg = -arg;
+		sign++;
+	}
+	if(arg > 1) {
+		errno = EDOM;
+		return 0;
+	}
+	temp = sqrt(1 - arg*arg);
+	if(arg > 0.7)
+		temp = pio2 - atan(temp/arg);
+	else
+		temp = atan(arg/temp);
+
+	if(sign)
+		temp = -temp;
+	return temp;
+}
+
+double
+acos(double arg)
+{
+	if(arg > 1 || arg < -1) {
+		errno = EDOM;
+		return 0;
+	}
+	return pio2 - asin(arg);
+}
diff --git a/sys/src/ape/lib/ap/math/atan.c b/sys/src/ape/lib/ap/math/atan.c
new file mode 100755
index 000000000..a5674d848
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/atan.c
@@ -0,0 +1,86 @@
+/*
+	floating-point arctangent
+
+	atan returns the value of the arctangent of its
+	argument in the range [-pi/2,pi/2].
+
+	atan2 returns the arctangent of arg1/arg2
+	in the range [-pi,pi].
+
+	there are no error returns.
+
+	coefficients are #5077 from Hart & Cheney. (19.56D)
+*/
+
+#include <math.h>
+
+#define sq2p1 2.414213562373095048802e0
+#define sq2m1  .414213562373095048802e0
+#define pio2 1.570796326794896619231e0
+#define pio4  .785398163397448309615e0
+#define p4  .161536412982230228262e2
+#define p3  .26842548195503973794141e3
+#define p2  .11530293515404850115428136e4
+#define p1  .178040631643319697105464587e4
+#define p0  .89678597403663861959987488e3
+#define q4  .5895697050844462222791e2
+#define q3  .536265374031215315104235e3
+#define q2  .16667838148816337184521798e4
+#define q1  .207933497444540981287275926e4
+#define q0  .89678597403663861962481162e3
+
+
+/*
+	xatan evaluates a series valid in the
+	range [-0.414...,+0.414...].
+ */
+
+static
+double
+xatan(double arg)
+{
+	double argsq, value;
+
+	/* get denormalized add in following if range arg**10 is much smaller
+	    than q1, so check for that case
+	*/
+	if(-.01 < arg && arg < .01)
+		value = p0/q0;
+	else {
+		argsq = arg*arg;
+		value = ((((p4*argsq + p3)*argsq + p2)*argsq + p1)*argsq + p0);
+		value = value/(((((argsq + q4)*argsq + q3)*argsq + q2)*argsq + q1)*argsq + q0);
+	}
+	return value*arg;
+}
+
+/*
+	satan reduces its argument (known to be positive)
+	to the range [0,0.414...] and calls xatan.
+ */
+
+static
+double
+satan(double arg)
+{
+
+	if(arg < sq2m1)
+		return xatan(arg);
+	if(arg > sq2p1)
+		return pio2 - xatan(1.0/arg);
+	return pio4 + xatan((arg-1.0)/(arg+1.0));
+}
+
+/*
+	atan makes its argument positive and
+	calls the inner routine satan.
+ */
+
+double
+atan(double arg)
+{
+
+	if(arg > 0)
+		return satan(arg);
+	return -satan(-arg);
+}
diff --git a/sys/src/ape/lib/ap/math/atan2.c b/sys/src/ape/lib/ap/math/atan2.c
new file mode 100755
index 000000000..51c535329
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/atan2.c
@@ -0,0 +1,30 @@
+#include <math.h>
+#include <errno.h>
+/*
+	atan2 discovers what quadrant the angle
+	is in and calls atan.
+*/
+#define pio2 1.5707963267948966192313217
+#define pi   3.1415926535897932384626434;
+
+double
+atan2(double arg1, double arg2)
+{
+
+	if(arg1 == 0.0 && arg2 == 0.0){
+		errno = EDOM;
+		return 0.0;
+	}
+	if(arg1+arg2 == arg1) {
+		if(arg1 >= 0)
+			return pio2;
+		return -pio2;
+	}
+	arg1 = atan(arg1/arg2);
+	if(arg2 < 0) {
+		if(arg1 <= 0)
+			return arg1 + pi;
+		return arg1 - pi;
+	}
+	return arg1;
+}
diff --git a/sys/src/ape/lib/ap/math/erf.c b/sys/src/ape/lib/ap/math/erf.c
new file mode 100755
index 000000000..60ba4ee05
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/erf.c
@@ -0,0 +1,116 @@
+#include <math.h>
+#include <errno.h>
+/*
+	C program for floating point error function
+
+	erf(x) returns the error function of its argument
+	erfc(x) returns 1 - erf(x)
+
+	erf(x) is defined by
+	${2 over sqrt(pi)} int from 0 to x e sup {-t sup 2} dt$
+
+	the entry for erfc is provided because of the
+	extreme loss of relative accuracy if erf(x) is
+	called for large x and the result subtracted
+	from 1. (e.g. for x= 10, 12 places are lost).
+
+	There are no error returns.
+
+	Calls exp.
+
+	Coefficients for large x are #5667 from Hart & Cheney (18.72D).
+*/
+
+#define M 7
+#define N 9
+static double torp = 1.1283791670955125738961589031;
+static double p1[] = {
+	0.804373630960840172832162e5,
+	0.740407142710151470082064e4,
+	0.301782788536507577809226e4,
+	0.380140318123903008244444e2,
+	0.143383842191748205576712e2,
+	-.288805137207594084924010e0,
+	0.007547728033418631287834e0,
+};
+static double q1[]  = {
+	0.804373630960840172826266e5,
+	0.342165257924628539769006e5,
+	0.637960017324428279487120e4,
+	0.658070155459240506326937e3,
+	0.380190713951939403753468e2,
+	0.100000000000000000000000e1,
+	0.0,
+};
+static double p2[]  = {
+	0.18263348842295112592168999e4,
+	0.28980293292167655611275846e4,
+	0.2320439590251635247384768711e4,
+	0.1143262070703886173606073338e4,
+	0.3685196154710010637133875746e3,
+	0.7708161730368428609781633646e2,
+	0.9675807882987265400604202961e1,
+	0.5641877825507397413087057563e0,
+	0.0,
+};
+static double q2[]  = {
+	0.18263348842295112595576438e4,
+	0.495882756472114071495438422e4,
+	0.60895424232724435504633068e4,
+	0.4429612803883682726711528526e4,
+	0.2094384367789539593790281779e4,
+	0.6617361207107653469211984771e3,
+	0.1371255960500622202878443578e3,
+	0.1714980943627607849376131193e2,
+	1.0,
+};
+
+double erfc(double);
+
+double
+erf(double arg)
+{
+	int sign;
+	double argsq;
+	double d, n;
+	int i;
+
+	errno = 0;
+	sign = 1;
+	if(arg < 0) {
+		arg = -arg;
+		sign = -1;
+	}
+	if(arg < 0.5) {
+		argsq = arg*arg;
+		for(n=0,d=0,i=M-1; i>=0; i--) {
+			n = n*argsq + p1[i];
+			d = d*argsq + q1[i];
+		}
+		return sign*torp*arg*n/d;
+	}
+	if(arg >= 10)
+		return sign;
+	return sign*(1 - erfc(arg));
+}
+
+double
+erfc(double arg)
+{
+	double n, d;
+	int i;
+
+	errno = 0;
+	if(arg < 0)
+		return 2 - erfc(-arg);
+	if(arg < 0.5)
+		return 1 - erf(arg);
+	if(arg >= 10)
+		return 0;
+
+	for(n=0,d=0,i=N-1; i>=0; i--) {
+		n = n*arg + p2[i];
+		d = d*arg + q2[i];
+	}
+	return exp(-arg*arg)*n/d;
+}
diff --git a/sys/src/ape/lib/ap/math/exp.c b/sys/src/ape/lib/ap/math/exp.c
new file mode 100755
index 000000000..06d21d70f
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/exp.c
@@ -0,0 +1,44 @@
+/*
+	exp returns the exponential function of its
+	floating-point argument.
+
+	The coefficients are #1069 from Hart and Cheney. (22.35D)
+*/
+
+#include <math.h>
+#include <errno.h>
+
+#define	p0  .2080384346694663001443843411e7
+#define	p1  .3028697169744036299076048876e5
+#define	p2  .6061485330061080841615584556e2
+#define	q0  .6002720360238832528230907598e7
+#define	q1  .3277251518082914423057964422e6
+#define	q2  .1749287689093076403844945335e4
+#define	log2e  1.4426950408889634073599247
+#define	sqrt2  1.4142135623730950488016887
+#define	maxf  10000
+
+double
+exp(double arg)
+{
+	double fract, temp1, temp2, xsq;
+	int ent;
+
+	if(arg == 0)
+		return 1;
+	if(arg < -maxf) {
+		errno = ERANGE;
+		return 0;
+	}
+	if(arg > maxf) {
+		errno = ERANGE;
+		return HUGE_VAL;
+	}
+	arg *= log2e;
+	ent = floor(arg);
+	fract = (arg-ent) - 0.5;
+	xsq = fract*fract;
+	temp1 = ((p2*xsq+p1)*xsq+p0)*fract;
+	temp2 = ((xsq+q2)*xsq+q1)*xsq + q0;
+	return ldexp(sqrt2*(temp2+temp1)/(temp2-temp1), ent);
+}
diff --git a/sys/src/ape/lib/ap/math/fabs.c b/sys/src/ape/lib/ap/math/fabs.c
new file mode 100755
index 000000000..5566e165b
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/fabs.c
@@ -0,0 +1,10 @@
+#include <math.h>
+
+double
+fabs(double arg)
+{
+
+	if(arg < 0)
+		return -arg;
+	return arg;
+}
diff --git a/sys/src/ape/lib/ap/math/floor.c b/sys/src/ape/lib/ap/math/floor.c
new file mode 100755
index 000000000..dfab000c1
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/floor.c
@@ -0,0 +1,26 @@
+#include <math.h>
+/*
+ * floor and ceil-- greatest integer <= arg
+ * (resp least >=)
+ */
+
+double
+floor(double d)
+{
+	double fract;
+
+	if(d < 0) {
+		fract = modf(-d, &d);
+		if(fract != 0.0)
+			d += 1;
+		d = -d;
+	} else
+		modf(d, &d);
+	return d;
+}
+
+double
+ceil(double d)
+{
+	return -floor(-d);
+}
diff --git a/sys/src/ape/lib/ap/math/fmod.c b/sys/src/ape/lib/ap/math/fmod.c
new file mode 100755
index 000000000..876c64c39
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/fmod.c
@@ -0,0 +1,27 @@
+/* floating-point mod function without infinity or NaN checking */
+#include <math.h>
+double
+fmod (double x, double y)
+{
+	int sign = 0, yexp;
+	double r, yfr;
+
+	if (y == 0)
+		return 0;
+	if (y < 0)
+		y = -y;
+	yfr = frexp (y, &yexp);
+	if (x < 0) {
+		sign = 1;
+		r = -x;
+	} else
+		r = x;
+	while (r >= y) {
+		int rexp;
+		double rfr = frexp (r, &rexp);
+		r -= ldexp (y, rexp - yexp - (rfr < yfr));
+	}
+	if (sign)
+		r = -r;
+	return r;
+}
diff --git a/sys/src/ape/lib/ap/math/gamma.c b/sys/src/ape/lib/ap/math/gamma.c
new file mode 100755
index 000000000..7b541042b
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/gamma.c
@@ -0,0 +1,116 @@
+#include <math.h>
+#include <errno.h>
+
+/*
+	C program for floating point log gamma function
+
+	gamma(x) computes the log of the absolute
+	value of the gamma function.
+	The sign of the gamma function is returned in the
+	external quantity signgam.
+
+	The coefficients for expansion around zero
+	are #5243 from Hart & Cheney; for expansion
+	around infinity they are #5404.
+
+	Calls log and sin.
+*/
+
+int	signgam;
+static double goobie	= 0.9189385332046727417803297;
+static double pi	= 3.1415926535897932384626434;
+
+#define M 6
+#define N 8
+static double p1[] = {
+	0.83333333333333101837e-1,
+	-.277777777735865004e-2,
+	0.793650576493454e-3,
+	-.5951896861197e-3,
+	0.83645878922e-3,
+	-.1633436431e-2,
+};
+static double p2[] = {
+	-.42353689509744089647e5,
+	-.20886861789269887364e5,
+	-.87627102978521489560e4,
+	-.20085274013072791214e4,
+	-.43933044406002567613e3,
+	-.50108693752970953015e2,
+	-.67449507245925289918e1,
+	0.0,
+};
+static double q2[] = {
+	-.42353689509744090010e5,
+	-.29803853309256649932e4,
+	0.99403074150827709015e4,
+	-.15286072737795220248e4,
+	-.49902852662143904834e3,
+	0.18949823415702801641e3,
+	-.23081551524580124562e2,
+	0.10000000000000000000e1,
+};
+
+static double
+asym(double arg)
+{
+	double n, argsq;
+	int i;
+
+	argsq = 1 / (arg*arg);
+	n = 0;
+	for(i=M-1; i>=0; i--)
+		n = n*argsq + p1[i];
+	return (arg-.5)*log(arg) - arg + goobie + n/arg;
+}
+
+static double
+pos(double arg)
+{
+	double n, d, s;
+	int i;
+
+	if(arg < 2)
+		return pos(arg+1)/arg;
+	if(arg > 3)
+		return (arg-1)*pos(arg-1);
+
+	s = arg - 2;
+	n = 0;
+	d = 0;
+	for(i=N-1; i>=0; i--){
+		n = n*s + p2[i];
+		d = d*s + q2[i];
+	}
+	return n/d;
+}
+
+static double
+neg(double arg)
+{
+	double temp;
+
+	arg = -arg;
+	temp = sin(pi*arg);
+	if(temp == 0) {
+		errno = EDOM;
+		return HUGE_VAL;
+	}
+	if(temp < 0)
+		temp = -temp;
+	else
+		signgam = -1;
+	return -log(arg*pos(arg)*temp/pi);
+}
+
+double
+gamma(double arg)
+{
+
+	signgam = 1;
+	if(arg <= 0)
+		return neg(arg);
+	if(arg > 8)
+		return asym(arg);
+	return log(pos(arg));
+}
diff --git a/sys/src/ape/lib/ap/math/hypot.c b/sys/src/ape/lib/ap/math/hypot.c
new file mode 100755
index 000000000..25457d8a9
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/hypot.c
@@ -0,0 +1,29 @@
+#include <math.h>
+/*
+ * sqrt(a^2 + b^2)
+ *	(but carefully)
+ */
+
+double
+hypot(double a, double b)
+{
+	double t;
+
+	if(a < 0)
+		a = -a;
+	if(b < 0)
+		b = -b;
+	if(a > b) {
+		t = a;
+		a = b;
+		b = t;
+	}
+	if(b == 0) 
+		return 0;
+	a /= b;
+	/*
+	 * pathological overflow possible
+	 * in the next line.
+	 */
+	return b * sqrt(1 + a*a);
+}
diff --git a/sys/src/ape/lib/ap/math/j0.c b/sys/src/ape/lib/ap/math/j0.c
new file mode 100755
index 000000000..7dea3c9d1
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/j0.c
@@ -0,0 +1,188 @@
+#include <math.h>
+#include <errno.h>
+/*
+	floating point Bessel's function
+	of the first and second kinds
+	of order zero
+
+	j0(x) returns the value of J0(x)
+	for all real values of x.
+
+	There are no error returns.
+	Calls sin, cos, sqrt.
+
+	There is a niggling bug in J0 which
+	causes errors up to 2e-16 for x in the
+	interval [-8,8].
+	The bug is caused by an inappropriate order
+	of summation of the series.  rhm will fix it
+	someday.
+
+	Coefficients are from Hart & Cheney.
+	#5849 (19.22D)
+	#6549 (19.25D)
+	#6949 (19.41D)
+
+	y0(x) returns the value of Y0(x)
+	for positive real values of x.
+	For x<=0, error number EDOM is set and a
+	large negative value is returned.
+
+	Calls sin, cos, sqrt, log, j0.
+
+	The values of Y0 have not been checked
+	to more than ten places.
+
+	Coefficients are from Hart & Cheney.
+	#6245 (18.78D)
+	#6549 (19.25D)
+	#6949 (19.41D)
+*/
+
+static double pzero, qzero;
+static double tpi	= .6366197723675813430755350535e0;
+static double pio4	= .7853981633974483096156608458e0;
+static double p1[] = {
+	0.4933787251794133561816813446e21,
+	-.1179157629107610536038440800e21,
+	0.6382059341072356562289432465e19,
+	-.1367620353088171386865416609e18,
+	0.1434354939140344111664316553e16,
+	-.8085222034853793871199468171e13,
+	0.2507158285536881945555156435e11,
+	-.4050412371833132706360663322e8,
+	0.2685786856980014981415848441e5,
+};
+static double q1[] = {
+	0.4933787251794133562113278438e21,
+	0.5428918384092285160200195092e19,
+	0.3024635616709462698627330784e17,
+	0.1127756739679798507056031594e15,
+	0.3123043114941213172572469442e12,
+	0.6699987672982239671814028660e9,
+	0.1114636098462985378182402543e7,
+	0.1363063652328970604442810507e4,
+	1.0
+};
+static double p2[] = {
+	0.5393485083869438325262122897e7,
+	0.1233238476817638145232406055e8,
+	0.8413041456550439208464315611e7,
+	0.2016135283049983642487182349e7,
+	0.1539826532623911470917825993e6,
+	0.2485271928957404011288128951e4,
+	0.0,
+};
+static double q2[] = {
+	0.5393485083869438325560444960e7,
+	0.1233831022786324960844856182e8,
+	0.8426449050629797331554404810e7,
+	0.2025066801570134013891035236e7,
+	0.1560017276940030940592769933e6,
+	0.2615700736920839685159081813e4,
+	1.0,
+};
+static double p3[] = {
+	-.3984617357595222463506790588e4,
+	-.1038141698748464093880530341e5,
+	-.8239066313485606568803548860e4,
+	-.2365956170779108192723612816e4,
+	-.2262630641933704113967255053e3,
+	-.4887199395841261531199129300e1,
+	0.0,
+};
+static double q3[] = {
+	0.2550155108860942382983170882e6,
+	0.6667454239319826986004038103e6,
+	0.5332913634216897168722255057e6,
+	0.1560213206679291652539287109e6,
+	0.1570489191515395519392882766e5,
+	0.4087714673983499223402830260e3,
+	1.0,
+};
+static double p4[] = {
+	-.2750286678629109583701933175e20,
+	0.6587473275719554925999402049e20,
+	-.5247065581112764941297350814e19,
+	0.1375624316399344078571335453e18,
+	-.1648605817185729473122082537e16,
+	0.1025520859686394284509167421e14,
+	-.3436371222979040378171030138e11,
+	0.5915213465686889654273830069e8,
+	-.4137035497933148554125235152e5,
+};
+static double q4[] = {
+	0.3726458838986165881989980e21,
+	0.4192417043410839973904769661e19,
+	0.2392883043499781857439356652e17,
+	0.9162038034075185262489147968e14,
+	0.2613065755041081249568482092e12,
+	0.5795122640700729537480087915e9,
+	0.1001702641288906265666651753e7,
+	0.1282452772478993804176329391e4,
+	1.0,
+};
+
+static
+asympt(double arg)
+{
+	double zsq, n, d;
+	int i;
+
+	zsq = 64 / (arg*arg);
+	for(n=0,d=0,i=6;i>=0;i--) {
+		n = n*zsq + p2[i];
+		d = d*zsq + q2[i];
+	}
+	pzero = n/d;
+	for(n=0,d=0,i=6;i>=0;i--) {
+		n = n*zsq + p3[i];
+		d = d*zsq + q3[i];
+	}
+	qzero = (8/arg)*(n/d);
+}
+
+double
+j0(double arg)
+{
+	double argsq, n, d;
+	int i;
+
+	if(arg < 0)
+		arg = -arg;
+	if(arg > 8) {
+		asympt(arg);
+		n = arg - pio4;
+		return sqrt(tpi/arg)*(pzero*cos(n) - qzero*sin(n));
+	}
+	argsq = arg*arg;
+	for(n=0,d=0,i=8;i>=0;i--) {
+		n = n*argsq + p1[i];
+		d = d*argsq + q1[i];
+	}
+	return n/d;
+}
+
+double
+y0(double arg)
+{
+	double argsq, n, d;
+	int i;
+
+	errno = 0;
+	if(arg <= 0) {
+		errno = EDOM;
+		return(-HUGE_VAL);
+	}
+	if(arg > 8) {
+		asympt(arg);
+		n = arg - pio4;
+		return sqrt(tpi/arg)*(pzero*sin(n) + qzero*cos(n));
+	}
+	argsq = arg*arg;
+	for(n=0,d=0,i=8;i>=0;i--) {
+		n = n*argsq + p4[i];
+		d = d*argsq + q4[i];
+	}
+	return n/d + tpi*j0(arg)*log(arg);
+}
diff --git a/sys/src/ape/lib/ap/math/j1.c b/sys/src/ape/lib/ap/math/j1.c
new file mode 100755
index 000000000..38c73fe2b
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/j1.c
@@ -0,0 +1,195 @@
+#include <math.h>
+#include <errno.h>
+/*
+	floating point Bessel's function
+	of the first and second kinds
+	of order one
+
+	j1(x) returns the value of J1(x)
+	for all real values of x.
+
+	There are no error returns.
+	Calls sin, cos, sqrt.
+
+	There is a niggling bug in J1 which
+	causes errors up to 2e-16 for x in the
+	interval [-8,8].
+	The bug is caused by an inappropriate order
+	of summation of the series.  rhm will fix it
+	someday.
+
+	Coefficients are from Hart & Cheney.
+	#6050 (20.98D)
+	#6750 (19.19D)
+	#7150 (19.35D)
+
+	y1(x) returns the value of Y1(x)
+	for positive real values of x.
+	For x<=0, error number EDOM is set and a
+	large negative value is returned.
+
+	Calls sin, cos, sqrt, log, j1.
+
+	The values of Y1 have not been checked
+	to more than ten places.
+
+	Coefficients are from Hart & Cheney.
+	#6447 (22.18D)
+	#6750 (19.19D)
+	#7150 (19.35D)
+*/
+
+static double pzero, qzero;
+static double tpi	= .6366197723675813430755350535e0;
+static double pio4	= .7853981633974483096156608458e0;
+static double p1[] = {
+	0.581199354001606143928050809e21,
+	-.6672106568924916298020941484e20,
+	0.2316433580634002297931815435e19,
+	-.3588817569910106050743641413e17,
+	0.2908795263834775409737601689e15,
+	-.1322983480332126453125473247e13,
+	0.3413234182301700539091292655e10,
+	-.4695753530642995859767162166e7,
+	0.2701122710892323414856790990e4,
+};
+static double q1[] = {
+	0.1162398708003212287858529400e22,
+	0.1185770712190320999837113348e20,
+	0.6092061398917521746105196863e17,
+	0.2081661221307607351240184229e15,
+	0.5243710262167649715406728642e12,
+	0.1013863514358673989967045588e10,
+	0.1501793594998585505921097578e7,
+	0.1606931573481487801970916749e4,
+	1.0,
+};
+static double p2[] = {
+	-.4435757816794127857114720794e7,
+	-.9942246505077641195658377899e7,
+	-.6603373248364939109255245434e7,
+	-.1523529351181137383255105722e7,
+	-.1098240554345934672737413139e6,
+	-.1611616644324610116477412898e4,
+	0.0,
+};
+static double q2[] = {
+	-.4435757816794127856828016962e7,
+	-.9934124389934585658967556309e7,
+	-.6585339479723087072826915069e7,
+	-.1511809506634160881644546358e7,
+	-.1072638599110382011903063867e6,
+	-.1455009440190496182453565068e4,
+	1.0,
+};
+static double p3[] = {
+	0.3322091340985722351859704442e5,
+	0.8514516067533570196555001171e5,
+	0.6617883658127083517939992166e5,
+	0.1849426287322386679652009819e5,
+	0.1706375429020768002061283546e4,
+	0.3526513384663603218592175580e2,
+	0.0,
+};
+static double q3[] = {
+	0.7087128194102874357377502472e6,
+	0.1819458042243997298924553839e7,
+	0.1419460669603720892855755253e7,
+	0.4002944358226697511708610813e6,
+	0.3789022974577220264142952256e5,
+	0.8638367769604990967475517183e3,
+	1.0,
+};
+static double p4[] = {
+	-.9963753424306922225996744354e23,
+	0.2655473831434854326894248968e23,
+	-.1212297555414509577913561535e22,
+	0.2193107339917797592111427556e20,
+	-.1965887462722140658820322248e18,
+	0.9569930239921683481121552788e15,
+	-.2580681702194450950541426399e13,
+	0.3639488548124002058278999428e10,
+	-.2108847540133123652824139923e7,
+	0.0,
+};
+static double q4[] = {
+	0.5082067366941243245314424152e24,
+	0.5435310377188854170800653097e22,
+	0.2954987935897148674290758119e20,
+	0.1082258259408819552553850180e18,
+	0.2976632125647276729292742282e15,
+	0.6465340881265275571961681500e12,
+	0.1128686837169442121732366891e10,
+	0.1563282754899580604737366452e7,
+	0.1612361029677000859332072312e4,
+	1.0,
+};
+
+static
+asympt(double arg)
+{
+	double zsq, n, d;
+	int i;
+
+	zsq = 64/(arg*arg);
+	for(n=0,d=0,i=6;i>=0;i--) {
+		n = n*zsq + p2[i];
+		d = d*zsq + q2[i];
+	}
+	pzero = n/d;
+	for(n=0,d=0,i=6;i>=0;i--) {
+		n = n*zsq + p3[i];
+		d = d*zsq + q3[i];
+	}
+	qzero = (8/arg)*(n/d);
+}
+
+double
+j1(double arg)
+{
+	double xsq, n, d, x;
+	int i;
+
+	x = arg;
+	if(x < 0)
+		x = -x;
+	if(x > 8) {
+		asympt(x);
+		n = x - 3*pio4;
+		n = sqrt(tpi/x)*(pzero*cos(n) - qzero*sin(n));
+		if(arg < 0)
+			n = -n;
+		return n;
+	}
+	xsq = x*x;
+	for(n=0,d=0,i=8;i>=0;i--) {
+		n = n*xsq + p1[i];
+		d = d*xsq + q1[i];
+	}
+	return arg*n/d;
+}
+
+double
+y1(double arg)
+{
+	double xsq, n, d, x;
+	int i;
+
+	errno = 0;
+	x = arg;
+	if(x <= 0) {
+		errno = EDOM;
+		return -HUGE_VAL;
+	}
+	if(x > 8) {
+		asympt(x);
+		n = x - 3*pio4;
+		return sqrt(tpi/x)*(pzero*sin(n) + qzero*cos(n));
+	}
+	xsq = x*x;
+	for(n=0,d=0,i=9;i>=0;i--) {
+		n = n*xsq + p4[i];
+		d = d*xsq + q4[i];
+	}
+	return x*n/d + tpi*(j1(x)*log(x)-1/x);
+}
diff --git a/sys/src/ape/lib/ap/math/jn.c b/sys/src/ape/lib/ap/math/jn.c
new file mode 100755
index 000000000..55e985d48
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/jn.c
@@ -0,0 +1,116 @@
+#include <math.h>
+#include <errno.h>
+
+/*
+	floating point Bessel's function of
+	the first and second kinds and of
+	integer order.
+
+	int n;
+	double x;
+	jn(n,x);
+
+	returns the value of Jn(x) for all
+	integer values of n and all real values
+	of x.
+
+	There are no error returns.
+	Calls j0, j1.
+
+	For n=0, j0(x) is called,
+	for n=1, j1(x) is called,
+	for n<x, forward recursion us used starting
+	from values of j0(x) and j1(x).
+	for n>x, a continued fraction approximation to
+	j(n,x)/j(n-1,x) is evaluated and then backward
+	recursion is used starting from a supposed value
+	for j(n,x). The resulting value of j(0,x) is
+	compared with the actual value to correct the
+	supposed value of j(n,x).
+
+	yn(n,x) is similar in all respects, except
+	that forward recursion is used for all
+	values of n>1.
+*/
+
+double	j0(double);
+double	j1(double);
+double	y0(double);
+double	y1(double);
+
+double
+jn(int n, double x)
+{
+	int i;
+	double a, b, temp;
+	double xsq, t;
+
+	if(n < 0) {
+		n = -n;
+		x = -x;
+	}
+	if(n == 0)
+		return j0(x);
+	if(n == 1)
+		return j1(x);
+	if(x == 0)
+		return 0;
+	if(n > x)
+		goto recurs;
+
+	a = j0(x);
+	b = j1(x);
+	for(i=1; i<n; i++) {
+		temp = b;
+		b = (2*i/x)*b - a;
+		a = temp;
+	}
+	return b;
+
+recurs:
+	xsq = x*x;
+	for(t=0,i=n+16; i>n; i--)
+		t = xsq/(2*i - t);
+	t = x/(2*n-t);
+
+	a = t;
+	b = 1;
+	for(i=n-1; i>0; i--) {
+		temp = b;
+		b = (2*i/x)*b - a;
+		a = temp;
+	}
+	return t*j0(x)/b;
+}
+
+double
+yn(int n, double x)
+{
+	int i;
+	int sign;
+	double a, b, temp;
+
+	if (x <= 0) {
+		errno = EDOM;
+		return -HUGE_VAL;
+	}
+	sign = 1;
+	if(n < 0) {
+		n = -n;
+		if(n%2 == 1)
+			sign = -1;
+	}
+	if(n == 0)
+		return y0(x);
+	if(n == 1)
+		return sign*y1(x);
+
+	a = y0(x);
+	b = y1(x);
+	for(i=1; i<n; i++) {
+		temp = b;
+		b = (2*i/x)*b - a;
+		a = temp;
+	}
+	return sign*b;
+}
diff --git a/sys/src/ape/lib/ap/math/log.c b/sys/src/ape/lib/ap/math/log.c
new file mode 100755
index 000000000..bc1c2e1cb
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/log.c
@@ -0,0 +1,62 @@
+/*
+	log returns the natural logarithm of its floating
+	point argument.
+
+	The coefficients are #2705 from Hart & Cheney. (19.38D)
+
+	It calls frexp.
+*/
+
+#include <math.h>
+#include <errno.h>
+
+#define	log2    0.693147180559945309e0
+#define	ln10o1  .4342944819032518276511
+#define	sqrto2  0.707106781186547524e0
+#define	p0      -.240139179559210510e2
+#define	p1      0.309572928215376501e2
+#define	p2      -.963769093377840513e1
+#define	p3      0.421087371217979714e0
+#define	q0      -.120069589779605255e2
+#define	q1      0.194809660700889731e2
+#define	q2      -.891110902798312337e1
+
+double
+log(double arg)
+{
+	double x, z, zsq, temp;
+	int exp;
+
+	if(arg <= 0) {
+		errno = (arg==0)? ERANGE : EDOM;
+		return -HUGE_VAL;
+	}
+	x = frexp(arg, &exp);
+	while(x < 0.5) {
+		x *= 2;
+		exp--;
+	}
+	if(x < sqrto2) {
+		x *= 2;
+		exp--;
+	}
+
+	z = (x-1) / (x+1);
+	zsq = z*z;
+
+	temp = ((p3*zsq + p2)*zsq + p1)*zsq + p0;
+	temp = temp/(((zsq + q2)*zsq + q1)*zsq + q0);
+	temp = temp*z + exp*log2;
+	return temp;
+}
+
+double
+log10(double arg)
+{
+
+	if(arg <= 0) {
+		errno = (arg==0)? ERANGE : EDOM;
+		return -HUGE_VAL;
+	}
+	return log(arg) * ln10o1;
+}
diff --git a/sys/src/ape/lib/ap/math/mkfile b/sys/src/ape/lib/ap/math/mkfile
new file mode 100755
index 000000000..5e2d7483f
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/mkfile
@@ -0,0 +1,27 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	asin.$O\
+	atan.$O\
+	atan2.$O\
+	erf.$O\
+	exp.$O\
+	fabs.$O\
+	floor.$O\
+	fmod.$O\
+	gamma.$O\
+	hypot.$O\
+	j0.$O\
+	j1.$O\
+	jn.$O\
+	log.$O\
+	pow.$O\
+	sin.$O\
+	sinh.$O\
+	tan.$O\
+	tanh.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE
diff --git a/sys/src/ape/lib/ap/math/modf.c b/sys/src/ape/lib/ap/math/modf.c
new file mode 100755
index 000000000..4326cf44a
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/modf.c
@@ -0,0 +1,53 @@
+#include <math.h>
+#include <errno.h>
+
+/* modf suitable for IEEE double-precision */
+
+#define	MASK	0x7ffL
+#define SIGN	0x80000000
+#define	SHIFT	20
+#define	BIAS	1022L
+
+typedef	union
+{
+	double	d;
+	struct
+	{
+		long	ms;
+		long	ls;
+	} i;
+} Cheat;
+
+double
+modf(double d, double *ip)
+{
+	Cheat x;
+	int e;
+
+	if(-1 < d && d < 1) {
+		*ip = 0;
+		return d;
+	}
+	x.d = d;
+	x.i.ms &= ~SIGN;
+	e = (x.i.ms >> SHIFT) & MASK;
+	if(e == MASK || e == 0){
+		errno = EDOM;
+		*ip = (d > 0)? HUGE_VAL : -HUGE_VAL;
+		return 0;
+	}
+	e -= BIAS;
+	if(e <= SHIFT+1) {
+		x.i.ms &= ~(0x1fffffL >> e);
+		x.i.ls = 0;
+	} else
+	if(e <= SHIFT+33)
+		x.i.ls &= ~(0x7fffffffL >> (e-SHIFT-2));
+	if(d > 0){
+		*ip = x.d;
+		return d - x.d;
+	}else{
+		*ip = -x.d;
+		return d + x.d;
+	}
+}
diff --git a/sys/src/ape/lib/ap/math/pow.c b/sys/src/ape/lib/ap/math/pow.c
new file mode 100755
index 000000000..9512a649b
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/pow.c
@@ -0,0 +1,76 @@
+#include <math.h>
+#include <errno.h>
+#include <limits.h>
+
+double
+pow(double x, double y) /* return x ^ y (exponentiation) */
+{
+	double xy, y1, ye;
+	long i;
+	int ex, ey, flip;
+
+	if(y == 0.0)
+		return 1.0;
+
+	flip = 0;
+	if(y < 0.){
+		y = -y;
+		flip = 1;
+	}
+	y1 = modf(y, &ye);
+	if(y1 != 0.0){
+		if(x <= 0.)
+			goto zreturn;
+		if(y1 > 0.5) {
+			y1 -= 1.;
+			ye += 1.;
+		}
+		xy = exp(y1 * log(x));
+	}else
+		xy = 1.0;
+	if(ye > LONG_MAX){
+		if(x <= 0.){
+ zreturn:
+			if(x || flip)
+				errno = EDOM;
+			return 0.;
+		}
+		if(flip){
+			if(y == .5)
+				return 1./sqrt(x);
+			y = -y;
+		}else if(y == .5)
+			return sqrt(x);
+		return exp(y * log(x));
+	}
+	x = frexp(x, &ex);
+	ey = 0;
+	i = ye;
+	if(i)
+		for(;;){
+			if(i & 1){
+				xy *= x;
+				ey += ex;
+			}
+			i >>= 1;
+			if(i == 0)
+				break;
+			x *= x;
+			ex <<= 1;
+			if(x < .5){
+				x += x;
+				ex -= 1;
+			}
+		}
+	if(flip){
+		xy = 1. / xy;
+		ey = -ey;
+	}
+	errno = 0;
+	x = ldexp(xy, ey);
+	if(errno && ey < 0) {
+		errno = 0;
+		x = 0.;
+	}
+	return x;
+}
diff --git a/sys/src/ape/lib/ap/math/sin.c b/sys/src/ape/lib/ap/math/sin.c
new file mode 100755
index 000000000..694a223f4
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/sin.c
@@ -0,0 +1,68 @@
+/*
+	C program for floating point sin/cos.
+	Calls modf.
+	There are no error exits.
+	Coefficients are #3370 from Hart & Cheney (18.80D).
+*/
+
+#include <math.h>
+
+#define	PIO2	1.570796326794896619231e0
+#define p0      .1357884097877375669092680e8
+#define p1     -.4942908100902844161158627e7
+#define p2      .4401030535375266501944918e6
+#define p3     -.1384727249982452873054457e5
+#define p4      .1459688406665768722226959e3
+#define q0      .8644558652922534429915149e7
+#define q1      .4081792252343299749395779e6
+#define q2      .9463096101538208180571257e4
+#define q3      .1326534908786136358911494e3
+
+static
+double
+sinus(double arg, int quad)
+{
+	double e, f, ysq, x, y, temp1, temp2;
+	int k;
+
+	x = arg;
+	if(x < 0) {
+		x = -x;
+		quad += 2;
+	}
+	x *= 1/PIO2;	/* underflow? */
+	if(x > 32764) {
+		y = modf(x, &e);
+		e += quad;
+		modf(0.25*e, &f);
+		quad = e - 4*f;
+	} else {
+		k = x;
+		y = x - k;
+		quad += k;
+		quad &= 3;
+	}
+	if(quad & 1)
+		y = 1-y;
+	if(quad > 1)
+		y = -y;
+
+	ysq = y*y;
+	temp1 = ((((p4*ysq+p3)*ysq+p2)*ysq+p1)*ysq+p0)*y;
+	temp2 = ((((ysq+q3)*ysq+q2)*ysq+q1)*ysq+q0);
+	return temp1/temp2;
+}
+
+double
+cos(double arg)
+{
+	if(arg < 0)
+		arg = -arg;
+	return sinus(arg, 1);
+}
+
+double
+sin(double arg)
+{
+	return sinus(arg, 0);
+}
diff --git a/sys/src/ape/lib/ap/math/sinh.c b/sys/src/ape/lib/ap/math/sinh.c
new file mode 100755
index 000000000..58c261b76
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/sinh.c
@@ -0,0 +1,71 @@
+/*
+	sinh(arg) returns the hyperbolic sine of its floating-
+	point argument.
+
+	The exponential function is called for arguments
+	greater in magnitude than 0.5.
+
+	A series is used for arguments smaller in magnitude than 0.5.
+	The coefficients are #2029 from Hart & Cheney. (20.36D)
+
+	cosh(arg) is computed from the exponential function for
+	all arguments.
+*/
+
+#include <math.h>
+#include <errno.h>
+
+static double p0  = -0.6307673640497716991184787251e+6;
+static double p1  = -0.8991272022039509355398013511e+5;
+static double p2  = -0.2894211355989563807284660366e+4;
+static double p3  = -0.2630563213397497062819489e+2;
+static double q0  = -0.6307673640497716991212077277e+6;
+static double q1   = 0.1521517378790019070696485176e+5;
+static double q2  = -0.173678953558233699533450911e+3;
+
+double
+sinh(double arg)
+{
+	double temp, argsq;
+	int sign;
+
+	sign = 1;
+	if(arg < 0) {
+		arg = - arg;
+		sign = -1;
+	}
+	if(arg > 21) {
+		if(arg >= HUGE_VAL){
+			errno = ERANGE;
+			temp = HUGE_VAL;
+		} else
+			temp = exp(arg)/2;
+		if(sign > 0)
+			return temp;
+		else
+			return -temp;
+	}
+
+	if(arg > 0.5)
+		return sign*(exp(arg) - exp(-arg))/2;
+
+	argsq = arg*arg;
+	temp = (((p3*argsq+p2)*argsq+p1)*argsq+p0)*arg;
+	temp /= (((argsq+q2)*argsq+q1)*argsq+q0);
+	return sign*temp;
+}
+
+double
+cosh(double arg)
+{
+	if(arg < 0)
+		arg = - arg;
+	if(arg > 21) {
+		if(arg >= HUGE_VAL){
+			errno = ERANGE;
+			return HUGE_VAL;
+		} else
+			return(exp(arg)/2);
+	}
+	return (exp(arg) + exp(-arg))/2;
+}
diff --git a/sys/src/ape/lib/ap/math/tan.c b/sys/src/ape/lib/ap/math/tan.c
new file mode 100755
index 000000000..5147f8bc1
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/tan.c
@@ -0,0 +1,70 @@
+/*
+	floating point tangent
+
+	A series is used after range reduction.
+	Coefficients are #4285 from Hart & Cheney. (19.74D)
+ */
+
+#include <math.h>
+#include <errno.h>
+
+static double invpi	  = 1.27323954473516268;
+static double p0	 = -0.1306820264754825668269611177e+5;
+static double p1	  = 0.1055970901714953193602353981e+4;
+static double p2	 = -0.1550685653483266376941705728e+2;
+static double p3	  = 0.3422554387241003435328470489e-1;
+static double p4	  = 0.3386638642677172096076369e-4;
+static double q0	 = -0.1663895238947119001851464661e+5;
+static double q1	  = 0.4765751362916483698926655581e+4;
+static double q2	 = -0.1555033164031709966900124574e+3;
+
+double
+tan(double arg)
+{
+	double sign, temp, e, x, xsq;
+	int flag, i;
+
+	flag = 0;
+	sign = 1;
+	if(arg < 0){
+		arg = -arg;
+		sign = -1;
+	}
+	arg = arg*invpi;   /* overflow? */
+	x = modf(arg, &e);
+	i = e;
+	switch(i%4) {
+	case 1:
+		x = 1 - x;
+		flag = 1;
+		break;
+
+	case 2:
+		sign = - sign;
+		flag = 1;
+		break;
+
+	case 3:
+		x = 1 - x;
+		sign = - sign;
+		break;
+
+	case 0:
+		break;
+	}
+
+	xsq = x*x;
+	temp = ((((p4*xsq+p3)*xsq+p2)*xsq+p1)*xsq+p0)*x;
+	temp = temp/(((xsq+q2)*xsq+q1)*xsq+q0);
+
+	if(flag == 1) {
+		if(temp == 0) {
+			errno = EDOM;
+			if (sign > 0)
+				return HUGE_VAL;
+			return -HUGE_VAL;
+		}
+		temp = 1/temp;
+	}
+	return sign*temp;
+}
diff --git a/sys/src/ape/lib/ap/math/tanh.c b/sys/src/ape/lib/ap/math/tanh.c
new file mode 100755
index 000000000..cad68362b
--- /dev/null
+++ b/sys/src/ape/lib/ap/math/tanh.c
@@ -0,0 +1,24 @@
+#include <math.h>
+
+/*
+	tanh(arg) computes the hyperbolic tangent of its floating
+	point argument.
+
+	sinh and cosh are called except for large arguments, which
+	would cause overflow improperly.
+ */
+
+double
+tanh(double arg)
+{
+
+	if(arg < 0) {
+		arg = -arg;
+		if(arg > 21)
+			return -1;
+		return -sinh(arg)/cosh(arg);
+	}
+	if(arg > 21)
+		return 1;
+	return sinh(arg)/cosh(arg);
+}
diff --git a/sys/src/ape/lib/ap/mips/cycles.c b/sys/src/ape/lib/ap/mips/cycles.c
new file mode 100755
index 000000000..1c32bc732
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/cycles.c
@@ -0,0 +1,5 @@
+void
+_cycles(unsigned long long *u)
+{
+	*u = 0;
+}
diff --git a/sys/src/ape/lib/ap/mips/getfcr.s b/sys/src/ape/lib/ap/mips/getfcr.s
new file mode 100755
index 000000000..9e84cbccd
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/getfcr.s
@@ -0,0 +1,15 @@
+TEXT	getfsr(SB), $0
+	MOVW	FCR31, R1
+	RET
+
+TEXT	setfsr(SB), $0
+	MOVW	R1, FCR31
+	RET
+
+TEXT	getfcr(SB), $0
+	MOVW	FCR31, R1
+	RET
+
+TEXT	setfcr(SB), $0
+	MOVW	R1, FCR31
+	RET
diff --git a/sys/src/ape/lib/ap/mips/lock.c b/sys/src/ape/lib/ap/mips/lock.c
new file mode 100755
index 000000000..f0ecbe22a
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/lock.c
@@ -0,0 +1,172 @@
+#define _LOCK_EXTENSION
+#include <stdlib.h>
+#include <string.h>
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+enum
+{
+	Pagesize	= 4096,
+	Semperpg	= Pagesize/(16*sizeof(unsigned int)),
+	Lockaddr	= 0x60000000,
+
+	POWER		= 0x320,
+	MAGNUM		= 0x330,
+	MAGNUMII	= 0x340,
+	R4K		= 0x500,
+};
+
+static	int arch;
+extern	int C_3ktas(int*);
+extern	int C_4ktas(int*);
+extern	int C_fcr0(void);
+
+static void
+lockinit(void)
+{
+	int n;
+
+	if(arch != 0)
+		return;	/* allow multiple calls */
+	arch = C_fcr0();
+	switch(arch) {
+	case POWER:
+		n = _SEGATTACH(0,  "lock", (void*)Lockaddr, Pagesize);
+		if(n < 0) {
+			arch = MAGNUM;
+			break;
+		}
+		memset((void*)Lockaddr, 0, Pagesize);
+		break;
+	case MAGNUM:
+	case MAGNUMII:
+	case R4K:
+		break;
+	default:
+		abort();
+	}
+	
+}
+
+void
+lock(Lock *lk)
+{
+	int *hwsem;
+	int hash;
+
+retry:
+	switch(arch) {
+	case 0:
+		lockinit();
+		goto retry;
+	case MAGNUM:
+	case MAGNUMII:
+		while(C_3ktas(&lk->val))
+			_SLEEP(0);
+		return;
+	case R4K:
+		for(;;){
+			while(lk->val)
+				;
+			if(C_4ktas(&lk->val) == 0)
+				return;
+		}
+		break;
+	case POWER:
+		/* Use low order lock bits to generate hash */
+		hash = ((int)lk/sizeof(int)) & (Semperpg-1);
+		hwsem = (int*)Lockaddr+hash;
+
+		for(;;) {
+			if((*hwsem & 1) == 0) {
+				if(lk->val)
+					*hwsem = 0;
+				else {
+					lk->val = 1;
+					*hwsem = 0;
+					return;
+				}
+			}
+			while(lk->val)
+				;
+		}
+	}	
+}
+
+int
+canlock(Lock *lk)
+{
+	int *hwsem;
+	int hash;
+
+retry:
+	switch(arch) {
+	case 0:
+		lockinit();
+		goto retry;
+	case MAGNUM:
+	case MAGNUMII:
+		if(C_3ktas(&lk->val))
+			return 0;
+		return 1;
+	case R4K:
+		if(C_4ktas(&lk->val))
+			return 0;
+		return 1;
+	case POWER:
+		/* Use low order lock bits to generate hash */
+		hash = ((int)lk/sizeof(int)) & (Semperpg-1);
+		hwsem = (int*)Lockaddr+hash;
+
+		if((*hwsem & 1) == 0) {
+			if(lk->val)
+				*hwsem = 0;
+			else {
+				lk->val = 1;
+				*hwsem = 0;
+				return 1;
+			}
+		}
+		return 0;
+	}	
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
+
+int
+tas(int *p)
+{
+	int *hwsem;
+	int hash;
+
+retry:
+	switch(arch) {
+	case 0:
+		lockinit();
+		goto retry;
+	case MAGNUM:
+	case MAGNUMII:
+		return C_3ktas(p);
+	case R4K:
+		return C_4ktas(p);
+	case POWER:
+		/* Use low order lock bits to generate hash */
+		hash = ((int)p/sizeof(int)) & (Semperpg-1);
+		hwsem = (int*)Lockaddr+hash;
+
+		if((*hwsem & 1) == 0) {
+			if(*p)
+				*hwsem = 0;
+			else {
+				*p = 1;
+				*hwsem = 0;
+				return 0;
+			}
+		}
+		return 1;
+	}	
+}
diff --git a/sys/src/ape/lib/ap/mips/main9.s b/sys/src/ape/lib/ap/mips/main9.s
new file mode 100755
index 000000000..a3c224ace
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/main9.s
@@ -0,0 +1,12 @@
+	TEXT	_main(SB), $16
+	MOVW	$setR30(SB), R30
+	JAL	_envsetup(SB)
+	MOVW	inargc-4(FP), R1
+	MOVW	$inargv+0(FP), R2
+	MOVW	R1, 4(R29)
+	MOVW	R2, 8(R29)
+	JAL	main(SB)
+loop:
+	MOVW	R1, 4(R29)
+	JAL	exit(SB)
+	JMP	loop
diff --git a/sys/src/ape/lib/ap/mips/main9p.s b/sys/src/ape/lib/ap/mips/main9p.s
new file mode 100755
index 000000000..adc6e00b3
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/main9p.s
@@ -0,0 +1,54 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+	MOVW	$setR30(SB), R30
+
+	/* _tos = arg */
+	MOVW	R1, _tos(SB)
+/*
+	MOVW	$0,FCR31
+	NOR	R0,R0
+	MOVD	$0.5, F26
+	SUBD	F26, F26, F24
+	ADDD	F26, F26, F28
+	ADDD	F28, F28, F30
+*/
+	MOVW	$8(SP), R1
+	MOVW	R1, _privates(SB)
+	MOVW	$NPRIVATES, R1
+	MOVW	R1, _nprivates(SB)
+
+	/* _profmain(); */
+	JAL	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVW	_tos+0(SB),R1
+	MOVW	4(R1),R2
+	MOVW	R2,(R1)
+
+	JAL	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVW	inargc-4(FP), R1
+	MOVW	$inargv+0(FP), R2
+	MOVW	environ(SB), R3
+	MOVW	R1, 4(R29)
+	MOVW	R2, 8(R29)
+	MOVW	R3, 12(R29)
+	JAL	main(SB)
+loop:
+	MOVW	R1, 4(R29)
+	JAL	exit(SB)
+	MOVW	$_profin(SB), R0	/* force loading of profile */
+	JMP	loop
+
+TEXT	_savearg(SB), 1, $0
+	RET
+
+TEXT	_callpc(SB), 1, $0
+	MOVW	argp-4(FP), R1
+	RET
diff --git a/sys/src/ape/lib/ap/mips/memchr.s b/sys/src/ape/lib/ap/mips/memchr.s
new file mode 100755
index 000000000..5d1c3cc85
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/memchr.s
@@ -0,0 +1,39 @@
+	TEXT	memchr(SB), $0
+MOVW R1, 0(FP)
+
+	MOVW	n+8(FP), R1
+	MOVW	s1+0(FP), R2
+	MOVBU	c+7(FP), R3
+	ADDU	R1, R2, R6
+
+	AND	$(~1), R1, R5
+	ADDU	R2, R5
+	BEQ	R2, R5, lt2
+
+l1:
+	MOVBU	0(R2), R4
+	MOVBU	1(R2), R7
+	BEQ	R3, R4, eq0
+	ADDU	$2, R2
+	BEQ	R3, R7, eq
+	BNE	R2, R5, l1
+
+lt2:
+	BEQ	R2, R6, zret
+
+l2:
+	MOVBU	(R2), R4
+	ADDU	$1, R2
+	BEQ	R3, R4, eq
+	BNE	R2, R6, l2
+zret:
+	MOVW	R0, R1
+	RET
+
+eq0:
+	MOVW	R2, R1
+	RET
+
+eq:
+	SUBU	$1,R2, R1
+	RET
diff --git a/sys/src/ape/lib/ap/mips/memcmp.s b/sys/src/ape/lib/ap/mips/memcmp.s
new file mode 100755
index 000000000..c9142f85e
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/memcmp.s
@@ -0,0 +1,114 @@
+	TEXT	memcmp(SB), $0
+MOVW R1, 0(FP)
+
+/*
+ * performance:
+ *	alligned about 1.0us/call and 17.4mb/sec
+ *	unalligned is about 3.1mb/sec
+ */
+
+	MOVW	n+8(FP), R3		/* R3 is count */
+	MOVW	s1+0(FP), R4		/* R4 is pointer1 */
+	MOVW	s2+4(FP), R5		/* R5 is pointer2 */
+	ADDU	R3,R4, R6		/* R6 is end pointer1 */
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word cmp.
+ */
+	SGT	$4,R3, R1
+	BNE	R1, out
+
+/*
+ * test if both pointers
+ * are similarly word alligned
+ */
+	XOR	R4,R5, R1
+	AND	$3, R1
+	BNE	R1, out
+
+/*
+ * byte at a time to word allign
+ */
+l1:
+	AND	$3,R4, R1
+	BEQ	R1, l2
+	MOVB	0(R4), R8
+	MOVB	0(R5), R9
+	ADDU	$1, R4
+	BNE	R8,R9, ne
+	ADDU	$1, R5
+	JMP	l1
+
+/*
+ * turn R3 into end pointer1-15
+ * cmp 16 at a time while theres room
+ */
+l2:
+	ADDU	$-15,R6, R3
+l3:
+	SGTU	R3,R4, R1
+	BEQ	R1, l4
+	MOVW	0(R4), R8
+	MOVW	0(R5), R9
+	MOVW	4(R4), R10
+	BNE	R8,R9, ne
+	MOVW	4(R5), R11
+	MOVW	8(R4), R8
+	BNE	R10,R11, ne1
+	MOVW	8(R5), R9
+	MOVW	12(R4), R10
+	BNE	R8,R9, ne
+	MOVW	12(R5), R11
+	ADDU	$16, R4
+	BNE	R10,R11, ne1
+	BNE	R8,R9, ne
+	ADDU	$16, R5
+	JMP	l3
+
+/*
+ * turn R3 into end pointer1-3
+ * cmp 4 at a time while theres room
+ */
+l4:
+	ADDU	$-3,R6, R3
+l5:
+	SGTU	R3,R4, R1
+	BEQ	R1, out
+	MOVW	0(R4), R8
+	MOVW	0(R5), R9
+	ADDU	$4, R4
+	BNE	R8,R9, ne	/* only works because big endian */
+	ADDU	$4, R5
+	JMP	l5
+
+/*
+ * last loop, cmp byte at a time
+ */
+out:
+	SGTU	R6,R4, R1
+	BEQ	R1, ret
+	MOVB	0(R4), R8
+	MOVB	0(R5), R9
+	ADDU	$1, R4
+	BNE	R8,R9, ne
+	ADDU	$1, R5
+	JMP	out
+
+ne1:
+	SGTU	R10,R11, R1
+	BNE	R1, ret
+	MOVW	$-1,R1
+	RET
+ne:
+	SGTU	R8,R9, R1
+	BNE	R1, ret
+	MOVW	$-1,R1
+ret:
+	RET
+	END
diff --git a/sys/src/ape/lib/ap/mips/memmove.s b/sys/src/ape/lib/ap/mips/memmove.s
new file mode 100755
index 000000000..c8e30a0b4
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/memmove.s
@@ -0,0 +1,161 @@
+	TEXT	memmove(SB), $0
+
+	JMP	move
+
+	TEXT	memcpy(SB), $0
+move:
+	MOVW	R1, s1+0(FP)
+
+	MOVW	n+8(FP), R3		/* R3 is count */
+	MOVW	R1, R4			/* R4 is to-pointer */
+	SGT	R0, R3, R5
+	BEQ	R5, ok
+	MOVW	(R0), R0		/* abort if negative count */
+ok:
+	MOVW	s2+4(FP), R5		/* R5 is from-pointer */
+	ADDU	R3,R5, R7		/* R7 is end from-pointer */
+	ADDU	R3,R4, R6		/* R6 is end to-pointer */
+
+/*
+ * easiest test is copy backwards if
+ * destination string has higher mem address
+ */
+	SGT	$4,R3, R2
+	SGTU	R4,R5, R1
+	BNE	R1, back
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word store.
+ */
+	BNE	R2, fout
+
+/*
+ * test if both pointers
+ * are similarly word aligned
+ */
+	XOR	R4,R5, R1
+	AND	$3, R1
+	BNE	R1, fout
+
+/*
+ * byte at a time to word align
+ */
+f1:
+	AND	$3,R4, R1
+	BEQ	R1, f2
+	MOVB	0(R5), R8
+	ADDU	$1, R5
+	MOVB	R8, 0(R4)
+	ADDU	$1, R4
+	JMP	f1
+
+/*
+ * turn R3 into to-end pointer-15
+ * copy 16 at a time while theres room.
+ * R6 is smaller than R7 --
+ * there are problems if R7 is 0.
+ */
+f2:
+	ADDU	$-15,R6, R3
+f3:
+	SGTU	R3,R4, R1
+	BEQ	R1, f4
+	MOVW	0(R5), R8
+	MOVW	4(R5), R9
+	MOVW	R8, 0(R4)
+	MOVW	8(R5), R8
+	MOVW	R9, 4(R4)
+	MOVW	12(R5), R9
+	ADDU	$16, R5
+	MOVW	R8, 8(R4)
+	MOVW	R9, 12(R4)
+	ADDU	$16, R4
+	JMP	f3
+
+/*
+ * turn R3 into to-end pointer-3
+ * copy 4 at a time while theres room
+ */
+f4:
+	ADDU	$-3,R6, R3
+f5:
+	SGTU	R3,R4, R1
+	BEQ	R1, fout
+	MOVW	0(R5), R8
+	ADDU	$4, R5
+	MOVW	R8, 0(R4)
+	ADDU	$4, R4
+	JMP	f5
+
+/*
+ * last loop, copy byte at a time
+ */
+fout:
+	BEQ	R7,R5, ret
+	MOVB	0(R5), R8
+	ADDU	$1, R5
+	MOVB	R8, 0(R4)
+	ADDU	$1, R4
+	JMP	fout
+
+/*
+ * whole thing repeated for backwards
+ */
+back:
+	BNE	R2, bout
+	XOR	R6,R7, R1
+	AND	$3, R1
+	BNE	R1, bout
+b1:
+	AND	$3,R7, R1
+	BEQ	R1, b2
+	MOVB	-1(R7), R8
+	ADDU	$-1, R7
+	MOVB	R8, -1(R6)
+	ADDU	$-1, R6
+	JMP	b1
+b2:
+	ADDU	$15,R5, R3
+b3:
+	SGTU	R7,R3, R1
+	BEQ	R1, b4
+	MOVW	-4(R7), R8
+	MOVW	-8(R7), R9
+	MOVW	R8, -4(R6)
+	MOVW	-12(R7), R8
+	MOVW	R9, -8(R6)
+	MOVW	-16(R7), R9
+	ADDU	$-16, R7
+	MOVW	R8, -12(R6)
+	MOVW	R9, -16(R6)
+	ADDU	$-16, R6
+	JMP	b3
+b4:
+	ADDU	$3,R5, R3
+b5:
+	SGTU	R7,R3, R1
+	BEQ	R1, bout
+	MOVW	-4(R7), R8
+	ADDU	$-4, R7
+	MOVW	R8, -4(R6)
+	ADDU	$-4, R6
+	JMP	b5
+
+bout:
+	BEQ	R7,R5, ret
+	MOVB	-1(R7), R8
+	ADDU	$-1, R7
+	MOVB	R8, -1(R6)
+	ADDU	$-1, R6
+	JMP	bout
+
+ret:
+	MOVW	s1+0(FP), R1
+	RET
+	END
diff --git a/sys/src/ape/lib/ap/mips/memset.s b/sys/src/ape/lib/ap/mips/memset.s
new file mode 100755
index 000000000..8c9467f45
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/memset.s
@@ -0,0 +1,88 @@
+	TEXT	memset(SB),$12
+MOVW R1, 0(FP)
+
+/*
+ * performance:
+ *	about 1us/call and 28mb/sec
+ */
+
+	MOVW	n+8(FP), R3		/* R3 is count */
+	MOVW	p+0(FP), R4		/* R4 is pointer */
+	MOVW	c+4(FP), R5		/* R5 is char */
+	ADDU	R3,R4, R6		/* R6 is end pointer */
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word store.
+ */
+	SGT	$4,R3, R1
+	BNE	R1, out
+
+/*
+ * turn R5 into a word of characters
+ */
+	AND	$0xff, R5
+	SLL	$8,R5, R1
+	OR	R1, R5
+	SLL	$16,R5, R1
+	OR	R1, R5
+
+/*
+ * store one byte at a time until pointer
+ * is alligned on a word boundary
+ */
+l1:
+	AND	$3,R4, R1
+	BEQ	R1, l2
+	MOVB	R5, 0(R4)
+	ADDU	$1, R4
+	JMP	l1
+
+/*
+ * turn R3 into end pointer-15
+ * store 16 at a time while theres room
+ */
+l2:
+	ADDU	$-15,R6, R3
+l3:
+	SGTU	R3,R4, R1
+	BEQ	R1, l4
+	MOVW	R5, 0(R4)
+	MOVW	R5, 4(R4)
+	ADDU	$16, R4
+	MOVW	R5, -8(R4)
+	MOVW	R5, -4(R4)
+	JMP	l3
+
+/*
+ * turn R3 into end pointer-3
+ * store 4 at a time while theres room
+ */
+l4:
+	ADDU	$-3,R6, R3
+l5:
+	SGTU	R3,R4, R1
+	BEQ	R1, out
+	MOVW	R5, 0(R4)
+	ADDU	$4, R4
+	JMP	l5
+
+/*
+ * last loop, store byte at a time
+ */
+out:
+	SGTU	R6,R4 ,R1
+	BEQ	R1, ret
+	MOVB	R5, 0(R4)
+	ADDU	$1, R4
+	JMP	out
+
+ret:
+	MOVW	s1+0(FP), R1
+	RET
+	END
diff --git a/sys/src/ape/lib/ap/mips/mkfile b/sys/src/ape/lib/ap/mips/mkfile
new file mode 100755
index 000000000..0896229a6
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/mkfile
@@ -0,0 +1,26 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	getfcr.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memchr.$O\
+	memcmp.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strchr.$O\
+	strcmp.$O\
+	strcpy.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/mips/notetramp.c b/sys/src/ape/lib/ap/mips/notetramp.c
new file mode 100755
index 000000000..cef6b563b
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r1 = ret;
+	if(ret == 0)
+		u->r1 = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP];
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/mips/setjmp.s b/sys/src/ape/lib/ap/mips/setjmp.s
new file mode 100755
index 000000000..32ff470eb
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/setjmp.s
@@ -0,0 +1,24 @@
+TEXT	setjmp(SB), 1, $-4
+	MOVW	R29, (R1)
+	MOVW	R31, 4(R1)
+	MOVW	$0, R1
+	RET
+
+TEXT	sigsetjmp(SB), 1, $-4
+	MOVW	savemask+4(FP), R2
+	MOVW	R2, 0(R1)
+	MOVW	$_psigblocked(SB), R2
+	MOVW	R2, 4(R1)
+	MOVW	R29, 8(R1)
+	MOVW	R31, 12(R1)
+	MOVW	$0, R1
+	RET
+
+TEXT	longjmp(SB), 1, $-4
+	MOVW	r+4(FP), R3
+	BNE	R3, ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVW	$1, R3		/* bless their pointed heads */
+ok:	MOVW	(R1), R29
+	MOVW	4(R1), R31
+	MOVW	R3, R1
+	RET
diff --git a/sys/src/ape/lib/ap/mips/strchr.s b/sys/src/ape/lib/ap/mips/strchr.s
new file mode 100755
index 000000000..e009ffad2
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/strchr.s
@@ -0,0 +1,63 @@
+	TEXT	strchr(SB), $0
+MOVW R1, 0(FP)
+	MOVB	c+7(FP), R4
+	MOVW	s+0(FP), R3
+
+	BEQ	R4, l2
+
+/*
+ * char is not null
+ */
+l1:
+	MOVB	(R3), R1
+	ADDU	$1, R3
+	BEQ	R1, ret
+	BNE	R1,R4, l1
+	JMP	rm1
+
+/*
+ * char is null
+ * align to word
+ */
+l2:
+	AND	$3,R3, R1
+	BEQ	R1, l3
+	MOVB	(R3), R1
+	ADDU	$1, R3
+	BNE	R1, l2
+	JMP	rm1
+
+l3:
+	MOVW	$0xff000000, R6
+	MOVW	$0x00ff0000, R7
+
+l4:
+	MOVW	(R3), R5
+	ADDU	$4, R3
+	AND	R6,R5, R1
+	AND	R7,R5, R2
+	BEQ	R1, b0
+	AND	$0xff00,R5, R1
+	BEQ	R2, b1
+	AND	$0xff,R5, R2
+	BEQ	R1, b2
+	BNE	R2, l4
+
+rm1:
+	ADDU	$-1,R3, R1
+	JMP	ret
+
+b2:
+	ADDU	$-2,R3, R1
+	JMP	ret
+
+b1:
+	ADDU	$-3,R3, R1
+	JMP	ret
+
+b0:
+	ADDU	$-4,R3, R1
+	JMP	ret
+
+ret:
+	RET
diff --git a/sys/src/ape/lib/ap/mips/strcmp.s b/sys/src/ape/lib/ap/mips/strcmp.s
new file mode 100755
index 000000000..da986a2ed
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/strcmp.s
@@ -0,0 +1,21 @@
+TEXT	strcmp(SB), $0
+
+	MOVW	s2+4(FP), R2
+
+l1:
+	MOVB	(R2), R3
+	MOVB	(R1), R4
+	ADDU	$1, R1
+	BEQ	R3, end
+	ADDU	$1, R2
+	BEQ	R3, R4, l1
+
+	SGTU	R4, R3, R1
+	BNE	R1, ret
+	MOVW	$-1, R1
+	RET
+
+end:
+	SGTU	R4, R3, R1
+ret:
+	RET
diff --git a/sys/src/ape/lib/ap/mips/strcpy.s b/sys/src/ape/lib/ap/mips/strcpy.s
new file mode 100755
index 000000000..77be42669
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/strcpy.s
@@ -0,0 +1,96 @@
+TEXT	strcpy(SB), $0
+
+	MOVW	s2+4(FP),R2		/* R2 is from pointer */
+	MOVW	R1, R3			/* R3 is to pointer */
+
+/*
+ * align 'from' pointer
+ */
+l1:
+	AND	$3, R2, R5
+	ADDU	$1, R2
+	BEQ	R5, l2
+	MOVB	-1(R2), R5
+	ADDU	$1, R3
+	MOVB	R5, -1(R3)
+	BNE	R5, l1
+	RET
+
+/*
+ * test if 'to' is also alligned
+ */
+l2:
+	AND	$3,R3, R5
+	BEQ	R5, l4
+
+/*
+ * copy 4 at a time, 'to' not aligned
+ */
+l3:
+	MOVW	-1(R2), R4
+	ADD	$4, R2
+	ADD	$4, R3
+	SRL	$24,R4, R5
+	MOVB	R5, -4(R3)
+	BEQ	R5, out
+
+	SRL	$16,R4, R5
+	AND	$0xff, R5
+	MOVB	R5, -3(R3)
+	BEQ	R5, out
+
+	SRL	$8,R4, R5
+	AND	$0xff, R5
+	MOVB	R5, -2(R3)
+	BEQ	R5, out
+
+	AND	$0xff,R4, R5
+	MOVB	R5, -1(R3)
+	BNE	R5, l3
+
+out:
+	RET
+
+/*
+ * word at a time both aligned
+ */
+l4:
+	MOVW	$0xff000000, R7
+	MOVW	$0x00ff0000, R8
+
+l5:
+	ADDU	$4, R3
+	MOVW	-1(R2), R4	/* fetch */
+
+	ADDU	$4, R2
+	AND	R7,R4, R5	/* is it byte 0 */
+	AND	R8,R4, R6	/* is it byte 1 */
+	BEQ	R5, b0
+
+	AND	$0xff00,R4, R5	/* is it byte 2 */
+	BEQ	R6, b1
+
+	AND	$0xff,R4, R6	/* is it byte 3 */
+	BEQ	R5, b2
+
+	MOVW	R4, -4(R3)	/* store */
+	BNE	R6, l5
+	JMP	out
+
+b0:
+	MOVB	$0, -4(R3)
+	JMP	out
+
+b1:
+	SRL	$24, R4
+	MOVB	R4, -4(R3)
+	MOVB	$0, -3(R3)
+	JMP	out
+
+b2:
+	SRL	$24,R4, R5
+	MOVB	R5, -4(R3)
+	SRL	$16, R4
+	MOVB	R4, -3(R3)
+	MOVB	$0, -2(R3)
+	JMP	out
diff --git a/sys/src/ape/lib/ap/mips/tas.s b/sys/src/ape/lib/ap/mips/tas.s
new file mode 100755
index 000000000..d754b21f6
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/tas.s
@@ -0,0 +1,33 @@
+/*
+ *	magnum user level lock code
+ */
+
+#define	LL(base, rt)	WORD	$((060<<26)|((base)<<21)|((rt)<<16))
+#define	SC(base, rt)	WORD	$((070<<26)|((base)<<21)|((rt)<<16))
+#define	NOOP		WORD	$0x27
+#define COP3		WORD	$(023<<26)
+
+	TEXT	C_3ktas(SB),$0
+	MOVW	R1, R21
+btas:
+	MOVW	R21, R1
+	MOVB	R0, 1(R1)
+	NOOP
+	COP3
+	BLTZ	R1, btas
+	RET
+
+	TEXT	C_4ktas(SB), $0
+	MOVW	R1, R2		/* address of key */
+tas1:
+	MOVW	$1, R3
+	LL(2, 1)
+	NOOP
+	SC(2, 3)
+	NOOP
+	BEQ	R3, tas1
+	RET
+
+	TEXT	C_fcr0(SB), $0
+	MOVW	FCR0, R1
+	RET
diff --git a/sys/src/ape/lib/ap/mips/vlop.s b/sys/src/ape/lib/ap/mips/vlop.s
new file mode 100755
index 000000000..17f487ad8
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/vlop.s
@@ -0,0 +1,17 @@
+TEXT	_mulv(SB), $0
+	MOVW	8(FP), R2
+	MOVW	4(FP), R3
+	MOVW	16(FP), R4
+	MOVW	12(FP), R5
+	MULU	R4, R2
+	MOVW	LO, R6
+	MOVW	HI, R7
+	MULU	R3, R4
+	MOVW	LO, R8
+	ADDU	R8, R7
+	MULU	R2, R5
+	MOVW	LO, R8
+	ADDU	R8, R7
+	MOVW	R6, 4(R1)
+	MOVW	R7, 0(R1)
+	RET
diff --git a/sys/src/ape/lib/ap/mips/vlrt.c b/sys/src/ape/lib/ap/mips/vlrt.c
new file mode 100755
index 000000000..964562775
--- /dev/null
+++ b/sys/src/ape/lib/ap/mips/vlrt.c
@@ -0,0 +1,719 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	union
+	{
+		struct
+		{
+			ulong	hi;
+			ulong	lo;
+		};
+		struct
+		{
+			ushort	hims;
+			ushort	hils;
+			ushort	loms;
+			ushort	lols;
+		};
+	};
+};
+
+void	abort(void);
+
+void
+_addv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo + b.lo;
+	hi = a.hi + b.hi;
+	if(lo < a.lo)
+		hi++;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_subv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo - b.lo;
+	hi = a.hi - b.hi;
+	if(lo > a.lo)
+		hi--;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; struct Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+static void
+dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
+{
+	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
+	int i;
+
+	numhi = num.hi;
+	numlo = num.lo;
+	denhi = den.hi;
+	denlo = den.lo;
+
+	/*
+	 * get a divide by zero
+	 */
+	if(denlo==0 && denhi==0) {
+		numlo = numlo / denlo;
+	}
+
+	/*
+	 * set up the divisor and find the number of iterations needed
+	 */
+	if(numhi >= SIGN(32)) {
+		quohi = SIGN(32);
+		quolo = 0;
+	} else {
+		quohi = numhi;
+		quolo = numlo;
+	}
+	i = 0;
+	while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
+		denhi = (denhi<<1) | (denlo>>31);
+		denlo <<= 1;
+		i++;
+	}
+
+	quohi = 0;
+	quolo = 0;
+	for(; i >= 0; i--) {
+		quohi = (quohi<<1) | (quolo>>31);
+		quolo <<= 1;
+		if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
+			t = numlo;
+			numlo -= denlo;
+			if(numlo > t)
+				numhi--;
+			numhi -= denhi;
+			quolo |= 1;
+		}
+		denlo = (denlo>>1) | (denhi<<31);
+		denhi >>= 1;
+	}
+
+	if(qp) {
+		qp->lo = quolo;
+		qp->hi = quohi;
+	}
+	if(rp) {
+		rp->lo = numlo;
+		rp->hi = numhi;
+	}
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	dodiv(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	dodiv(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_rshav(Vlong *r, Vlong a, int b)
+{
+	long t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = t>>31;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = t>>31;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_rshlv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = 0;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_lshv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.lo;
+	if(b >= 32) {
+		r->lo = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->hi = 0;
+			return;
+		}
+		r->hi = t << (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->lo = t;
+		r->hi = a.hi;
+		return;
+	}
+	r->lo = t << b;
+	r->hi = (t >> (32-b)) | (a.hi << b);
+}
+
+void
+_andv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi & b.hi;
+	r->lo = a.lo & b.lo;
+}
+
+void
+_orv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi | b.hi;
+	r->lo = a.lo | b.lo;
+}
+
+void
+_xorv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi ^ b.hi;
+	r->lo = a.lo ^ b.lo;
+}
+
+void
+_vpp(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+}
+
+void
+_vmm(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+}
+
+void
+_ppv(Vlong *l, Vlong *r)
+{
+
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_mmv(Vlong *l, Vlong *r)
+{
+
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u.lo = 0;
+	u.hi = 0;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
+
+void
+_p2v(Vlong *ret, void *p)
+{
+	long t;
+
+	t = (ulong)p;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sl2v(Vlong *ret, long sl)
+{
+	long t;
+
+	t = sl;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ul2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_si2v(Vlong *ret, int si)
+{
+	long t;
+
+	t = si;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ui2v(Vlong *ret, uint ui)
+{
+	long t;
+
+	t = ui;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sh2v(Vlong *ret, long sh)
+{
+	long t;
+
+	t = (sh << 16) >> 16;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uh2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xffff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sc2v(Vlong *ret, long uc)
+{
+	long t;
+
+	t = (uc << 24) >> 24;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uc2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+long
+_v2sc(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xff;
+	return (t << 24) >> 24;
+}
+
+long
+_v2uc(Vlong rv)
+{
+
+	return rv.lo & 0xff;
+}
+
+long
+_v2sh(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xffff;
+	return (t << 16) >> 16;
+}
+
+long
+_v2uh(Vlong rv)
+{
+
+	return rv.lo & 0xffff;
+}
+
+long
+_v2sl(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ul(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2si(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ui(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+int
+_testv(Vlong rv)
+{
+	return rv.lo || rv.hi;
+}
+
+int
+_eqv(Vlong lv, Vlong rv)
+{
+	return lv.lo == rv.lo && lv.hi == rv.hi;
+}
+
+int
+_nev(Vlong lv, Vlong rv)
+{
+	return lv.lo != rv.lo || lv.hi != rv.hi;
+}
+
+int
+_ltv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_gtv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_gev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
+
+int
+_lov(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lsv(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_hiv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_hsv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
diff --git a/sys/src/ape/lib/ap/mkfile b/sys/src/ape/lib/ap/mkfile
new file mode 100755
index 000000000..fa7d240e6
--- /dev/null
+++ b/sys/src/ape/lib/ap/mkfile
@@ -0,0 +1,24 @@
+APE=/sys/src/ape
+<$APE/config
+
+DIRS=gen math plan9 posix stdio syscall
+
+default:V:	all
+
+install all:V:
+	for(i in $DIRS $objtype)@{
+		echo $i
+		cd $i
+		mk $MKFLAGS $target
+	}
+
+installall:V:
+	for(objtype in $CPUS) mk $MKFLAGS install
+
+
+clean nuke:V:
+	for(i in $DIRS $CPUS)@{
+		echo $i
+		cd $i
+		mk $MKFLAGS $target
+	}
diff --git a/sys/src/ape/lib/ap/plan9/9errstr.c b/sys/src/ape/lib/ap/plan9/9errstr.c
new file mode 100755
index 000000000..31226c18b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9errstr.c
@@ -0,0 +1,4 @@
+#include "sys9.h"
+
+int
+_ERRSTR(
\ No newline at end of file
diff --git a/sys/src/ape/lib/ap/plan9/9iounit.c b/sys/src/ape/lib/ap/plan9/9iounit.c
new file mode 100755
index 000000000..7117a9fe0
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9iounit.c
@@ -0,0 +1,65 @@
+#include "lib.h"
+#include <string.h>
+#include <stdlib.h>
+#include <fmt.h>
+#include "sys9.h"
+#include "dir.h"
+
+/*
+ * Format:
+  3 r  M    4 (0000000000457def 11 00)   8192      512 /rc/lib/rcmain
+ */
+
+static int
+getfields(char *str, char **args, int max, int mflag)
+{
+	char r;
+	int nr, intok, narg;
+
+	if(max <= 0)
+		return 0;
+
+	narg = 0;
+	args[narg] = str;
+	if(!mflag)
+		narg++;
+	intok = 0;
+	for(;;) {
+		r = *str++;
+		if(r == 0)
+			break;
+		if(r == ' ' || r == '\t'){
+			if(narg >= max)
+				break;
+			*str = 0;
+			intok = 0;
+			args[narg] = str + nr;
+			if(!mflag)
+				narg++;
+		} else {
+			if(!intok && mflag)
+				narg++;
+			intok = 1;
+		}
+	}
+	return narg;
+}
+int
+_IOUNIT(int fd)
+{
+	int i, cfd;
+	char buf[128], *args[10];
+
+	snprint(buf, sizeof buf, "#d/%dctl", fd);
+	cfd = _OPEN(buf, OREAD);
+	if(cfd < 0)
+		return 0;
+	i = _READ(cfd, buf, sizeof buf-1);
+	_CLOSE(cfd);
+	if(i <= 0)
+		return 0;
+	buf[i] = '\0';
+	if(getfields(buf, args, 10, 1) != 10)
+		return 0;
+	return atoi(args[7]);
+}
diff --git a/sys/src/ape/lib/ap/plan9/9mallocz.c b/sys/src/ape/lib/ap/plan9/9mallocz.c
new file mode 100755
index 000000000..de5edb266
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9mallocz.c
@@ -0,0 +1,14 @@
+#include <stdlib.h>
+#include <string.h>
+
+void*
+_MALLOCZ(int n, int clr)
+{
+	void *v;
+
+	v = malloc(n);
+	if(v && clr)
+		memset(v, 0, n);
+	return v;
+}
+
diff --git a/sys/src/ape/lib/ap/plan9/9read.c b/sys/src/ape/lib/ap/plan9/9read.c
new file mode 100755
index 000000000..ce38b3908
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9read.c
@@ -0,0 +1,11 @@
+#include "lib.h"
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+long
+_READ(int fd, void *buf, long n)
+{
+	return _PREAD(fd, buf, n, -1LL);
+}
diff --git a/sys/src/ape/lib/ap/plan9/9readn.c b/sys/src/ape/lib/ap/plan9/9readn.c
new file mode 100755
index 000000000..8a0f5615c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9readn.c
@@ -0,0 +1,21 @@
+#include "sys9.h"
+
+long
+_READN(int f, void *av, long n)
+{
+	char *a;
+	long m, t;
+
+	a = av;
+	t = 0;
+	while(t < n){
+		m = _READ(f, a+t, n-t);
+		if(m <= 0){
+			if(t == 0)
+				return m;
+			break;
+		}
+		t += m;
+	}
+	return t;
+}
diff --git a/sys/src/ape/lib/ap/plan9/9wait.c b/sys/src/ape/lib/ap/plan9/9wait.c
new file mode 100755
index 000000000..71771df0b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9wait.c
@@ -0,0 +1,93 @@
+#include "lib.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+static char qsep[] = " \t\r\n";
+
+static char*
+qtoken(char *s)
+{
+	int quoting;
+	char *t;
+
+	quoting = 0;
+	t = s;	/* s is output string, t is input string */
+	while(*t!='\0' && (quoting || strchr(qsep, *t)==nil)){
+		if(*t != '\''){
+			*s++ = *t++;
+			continue;
+		}
+		/* *t is a quote */
+		if(!quoting){
+			quoting = 1;
+			t++;
+			continue;
+		}
+		/* quoting and we're on a quote */
+		if(t[1] != '\''){
+			/* end of quoted section; absorb closing quote */
+			t++;
+			quoting = 0;
+			continue;
+		}
+		/* doubled quote; fold one quote into two */
+		t++;
+		*s++ = *t++;
+	}
+	if(*s != '\0'){
+		*s = '\0';
+		if(t == s)
+			t++;
+	}
+	return t;
+}
+
+static int
+tokenize(char *s, char **args, int maxargs)
+{
+	int nargs;
+
+	for(nargs=0; nargs<maxargs; nargs++){
+		while(*s!='\0' && strchr(qsep, *s)!=nil)
+			s++;
+		if(*s == '\0')
+			break;
+		args[nargs] = s;
+		s = qtoken(s);
+	}
+
+	return nargs;
+}
+
+Waitmsg*
+_WAIT(void)
+{
+	int n, l;
+	char buf[512], *fld[5];
+	Waitmsg *w;
+
+	n = _AWAIT(buf, sizeof buf-1);
+	if(n < 0)
+		return nil;
+	buf[n] = '\0';
+	if(tokenize(buf, fld, 5) != 5){
+		strcpy(buf, "couldn't parse wait message");
+		_ERRSTR(buf, sizeof buf);
+		return nil;
+	}
+	l = strlen(fld[4])+1;
+	w = malloc(sizeof(Waitmsg)+l);
+	if(w == nil)
+		return nil;
+	w->pid = atoi(fld[0]);
+	w->time[0] = atoi(fld[1]);
+	w->time[1] = atoi(fld[2]);
+	w->time[2] = atoi(fld[3]);
+	w->msg = (char*)&w[1];
+	memmove(w->msg, fld[4], l);
+	return w;
+}
+
diff --git a/sys/src/ape/lib/ap/plan9/9write.c b/sys/src/ape/lib/ap/plan9/9write.c
new file mode 100755
index 000000000..e87a45ade
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/9write.c
@@ -0,0 +1,11 @@
+#include "lib.h"
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+long
+_WRITE(int fd, void *buf, long n)
+{
+	return _PWRITE(fd, buf, n, -1LL);
+}
diff --git a/sys/src/ape/lib/ap/plan9/_buf.c b/sys/src/ape/lib/ap/plan9/_buf.c
new file mode 100755
index 000000000..21fe282bb
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_buf.c
@@ -0,0 +1,472 @@
+#define  _BSDTIME_EXTENSION
+#define _LOCK_EXTENSION
+#include "lib.h"
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <lock.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <unistd.h>
+#include "sys9.h"
+
+typedef struct Muxseg {
+	Lock	lock;			/* for mutual exclusion access to buffer variables */
+	int	curfds;			/* number of fds currently buffered */
+	int	selwait;		/* true if selecting process is waiting */
+	int	waittime;		/* time for timer process to wait */
+	fd_set	rwant;			/* fd's that select wants to read */
+	fd_set	ewant;			/* fd's that select wants to know eof info on */
+	Muxbuf	bufs[INITBUFS];		/* can grow, via segbrk() */
+} Muxseg;
+
+#define MUXADDR ((void*)0x6000000)
+static Muxseg *mux = 0;			/* shared memory segment */
+
+/* _muxsid and _killmuxsid are known in libbsd's listen.c */
+int _muxsid = -1;			/* group id of copy processes */
+static int _mainpid = -1;
+static int timerpid = -1;		/* pid of a timer process */
+
+void _killmuxsid(void);
+static void _copyproc(int, Muxbuf*);
+static void _timerproc(void);
+static void _resettimer(void);
+
+static int copynotehandler(void *, char *);
+
+/* assume FD_SETSIZE is 96 */
+#define FD_ANYSET(p)	((p)->fds_bits[0] || (p)->fds_bits[1] || (p)->fds_bits[2])
+
+/*
+ * Start making fd read-buffered: make the shared segment, if necessary,
+ * allocate a slot (index into mux->bufs), and fork a child to read the fd
+ * and write into the slot-indexed buffer.
+ * Return -1 if we can't do it.
+ */
+int
+_startbuf(int fd)
+{
+	long i, n, slot;
+	int pid, sid;
+	Fdinfo *f;
+	Muxbuf *b;
+
+	if(mux == 0){
+		_RFORK(RFREND);
+		mux = (Muxseg*)_SEGATTACH(0, "shared", MUXADDR, sizeof(Muxseg));
+		if((long)mux == -1){
+			_syserrno();
+			return -1;
+		}
+		/* segattach has returned zeroed memory */
+		atexit(_killmuxsid);
+	}
+
+	if(fd == -1)
+		return 0;
+
+	lock(&mux->lock);
+	slot = mux->curfds++;
+	if(mux->curfds > INITBUFS) {
+		if(_SEGBRK(mux, mux->bufs+mux->curfds) < 0){
+			_syserrno();
+			unlock(&mux->lock);
+			return -1;
+		}
+	}
+
+	f = &_fdinfo[fd];
+	b = &mux->bufs[slot];
+	b->n = 0;
+	b->putnext = b->data;
+	b->getnext = b->data;
+	b->eof = 0;
+	b->fd = fd;
+	if(_mainpid == -1)
+		_mainpid = getpid();
+	if((pid = _RFORK(RFFDG|RFPROC|RFNOWAIT)) == 0){
+		/* copy process ... */
+		if(_muxsid == -1) {
+			_RFORK(RFNOTEG);
+			_muxsid = getpgrp();
+		} else
+			setpgid(getpid(), _muxsid);
+		_NOTIFY(copynotehandler);
+		for(i=0; i<OPEN_MAX; i++)
+			if(i!=fd && (_fdinfo[i].flags&FD_ISOPEN))
+				_CLOSE(i);
+		_RENDEZVOUS(0, _muxsid);
+		_copyproc(fd, b);
+	}
+
+	/* parent process continues ... */
+	b->copypid = pid;
+	f->buf = b;
+	f->flags |= FD_BUFFERED;
+	unlock(&mux->lock);
+	_muxsid = _RENDEZVOUS(0, 0);
+	/* leave fd open in parent so system doesn't reuse it */
+	return 0;
+}
+
+/*
+ * The given buffered fd is being closed.
+ * Set the fd field in the shared buffer to -1 to tell copyproc
+ * to exit, and kill the copyproc.
+ */
+void
+_closebuf(int fd)
+{
+	Muxbuf *b;
+
+	b = _fdinfo[fd].buf;
+	if(!b)
+		return;
+	lock(&mux->lock);
+	b->fd = -1;
+	unlock(&mux->lock);
+	kill(b->copypid, SIGKILL);
+}
+
+/* child copy procs execute this until eof */
+static void
+_copyproc(int fd, Muxbuf *b)
+{
+	unsigned char *e;
+	int n;
+	int nzeros;
+
+	e = &b->data[PERFDMAX];
+	for(;;) {
+		/* make sure there's room */
+		lock(&mux->lock);
+		if(e - b->putnext < READMAX) {
+			if(b->getnext == b->putnext) {
+				b->getnext = b->putnext = b->data;
+				unlock(&mux->lock);
+			} else {
+				/* sleep until there's room */
+				b->roomwait = 1;
+				unlock(&mux->lock);
+				_RENDEZVOUS((unsigned long)&b->roomwait, 0);
+			}
+		} else
+			unlock(&mux->lock);
+		/*
+		 * A Zero-length _READ might mean a zero-length write
+		 * happened, or it might mean eof; try several times to
+		 * disambiguate (posix read() discards 0-length messages)
+		 */
+		nzeros = 0;
+		do {
+			n = _READ(fd, b->putnext, READMAX);
+			if(b->fd == -1) {
+				_exit(0);		/* we've been closed */
+			}
+		} while(n == 0 && ++nzeros < 3);
+		lock(&mux->lock);
+		if(n <= 0) {
+			b->eof = 1;
+			if(mux->selwait && FD_ISSET(fd, &mux->ewant)) {
+				mux->selwait = 0;
+				unlock(&mux->lock);
+				_RENDEZVOUS((unsigned long)&mux->selwait, fd);
+			} else if(b->datawait) {
+				b->datawait = 0;
+				unlock(&mux->lock);
+				_RENDEZVOUS((unsigned long)&b->datawait, 0);
+			} else if(mux->selwait && FD_ISSET(fd, &mux->rwant)) {
+				mux->selwait = 0;
+				unlock(&mux->lock);
+				_RENDEZVOUS((unsigned long)&mux->selwait, fd);
+			} else
+				unlock(&mux->lock);
+			_exit(0);
+		} else {
+			b->putnext += n;
+			b->n += n;
+			if(b->n > 0) {
+				/* parent process cannot be both in datawait and selwait */
+				if(b->datawait) {
+					b->datawait = 0;
+					unlock(&mux->lock);
+					/* wake up _bufreading process */
+					_RENDEZVOUS((unsigned long)&b->datawait, 0);
+				} else if(mux->selwait && FD_ISSET(fd, &mux->rwant)) {
+					mux->selwait = 0;
+					unlock(&mux->lock);
+					/* wake up selecting process */
+					_RENDEZVOUS((unsigned long)&mux->selwait, fd);
+				} else
+					unlock(&mux->lock);
+			} else
+				unlock(&mux->lock);
+		}
+	}
+}
+
+/* like read(), for a buffered fd; extra arg noblock says don't wait for data if true */
+int
+_readbuf(int fd, void *addr, int nwant, int noblock)
+{
+	Muxbuf *b;
+	int ngot;
+
+	b = _fdinfo[fd].buf;
+	if(b->eof && b->n == 0) {
+goteof:
+		return 0;
+	}
+	if(b->n == 0 && noblock) {
+		errno = EAGAIN;
+		return -1;
+	}
+	/* make sure there's data */
+	lock(&mux->lock);
+	ngot = b->putnext - b->getnext;
+	if(ngot == 0) {
+		/* maybe EOF just happened */
+		if(b->eof) {
+			unlock(&mux->lock);
+			goto goteof;
+		}
+		/* sleep until there's data */
+		b->datawait = 1;
+		unlock(&mux->lock);
+		_RENDEZVOUS((unsigned long)&b->datawait, 0);
+		lock(&mux->lock);
+		ngot = b->putnext - b->getnext;
+	}
+	if(ngot == 0) {
+		unlock(&mux->lock);
+		goto goteof;
+	}
+	if(ngot > nwant)
+		ngot = nwant;
+	memcpy(addr, b->getnext, ngot);
+	b->getnext += ngot;
+	b->n -= ngot;
+	if(b->getnext == b->putnext && b->roomwait) {
+		b->getnext = b->putnext = b->data;
+		b->roomwait = 0;
+		unlock(&mux->lock);
+		/* wake up copy process */
+		_RENDEZVOUS((unsigned long)&b->roomwait, 0);
+	} else
+		unlock(&mux->lock);
+	return ngot;
+}
+
+int
+select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout)
+{
+	int n, i, tmp, t, slots, fd, err;
+	Fdinfo *f;
+	Muxbuf *b;
+
+	if(timeout)
+		t = timeout->tv_sec*1000 + (timeout->tv_usec+999)/1000;
+	else
+		t = -1;
+	if(!((rfds && FD_ANYSET(rfds)) || (wfds && FD_ANYSET(wfds))
+			|| (efds && FD_ANYSET(efds)))) {
+		/* no requested fds */
+		if(t > 0)
+			_SLEEP(t);
+		return 0;
+	}
+
+	_startbuf(-1);
+
+	/* make sure all requested rfds and efds are buffered */
+	if(nfds >= OPEN_MAX)
+		nfds = OPEN_MAX;
+	for(i = 0; i < nfds; i++)
+		if((rfds && FD_ISSET(i, rfds)) || (efds && FD_ISSET(i, efds))){
+			f = &_fdinfo[i];
+			if(!(f->flags&FD_BUFFERED))
+				if(_startbuf(i) != 0) {
+					return -1;
+				}
+			b = f->buf;
+			if(rfds && FD_ISSET(i,rfds) && b->eof && b->n == 0)
+			if(efds == 0 || !FD_ISSET(i,efds)) {
+				errno = EBADF;		/* how X tells a client is gone */
+				return -1;
+			}
+		}
+
+	/* check wfds;  for now, we'll say they are all ready */
+	n = 0;
+	if(wfds && FD_ANYSET(wfds)){
+		for(i = 0; i<nfds; i++)
+			if(FD_ISSET(i, wfds)) {
+				n++;
+			}
+	}
+
+	lock(&mux->lock);
+
+	slots = mux->curfds;
+	FD_ZERO(&mux->rwant);
+	FD_ZERO(&mux->ewant);
+
+	for(i = 0; i<slots; i++) {
+		b = &mux->bufs[i];
+		fd = b->fd;
+		if(fd == -1)
+			continue;
+		err = 0;
+		if(efds && FD_ISSET(fd, efds)) {
+			if(b->eof && b->n == 0){
+				err = 1;
+				n++;
+			}else{
+				FD_CLR(fd, efds);
+				FD_SET(fd, &mux->ewant);
+			}
+		}
+		if(rfds && FD_ISSET(fd, rfds)) {
+			if(!err && (b->n > 0 || b->eof))
+				n++;
+			else{
+				FD_CLR(fd, rfds);
+				FD_SET(fd, &mux->rwant);
+			}
+		}
+	}
+	if(n || !(FD_ANYSET(&mux->rwant) || FD_ANYSET(&mux->ewant)) || t == 0) {
+		FD_ZERO(&mux->rwant);
+		FD_ZERO(&mux->ewant);
+		unlock(&mux->lock);
+		return n;
+	}
+
+	if(timeout) {
+		mux->waittime = t;
+		if(timerpid == -1)
+			_timerproc();
+		else
+			_resettimer();
+	}
+	mux->selwait = 1;
+	unlock(&mux->lock);
+	fd = _RENDEZVOUS((unsigned long)&mux->selwait, 0);
+	if(fd >= 0) {
+		b = _fdinfo[fd].buf;
+		if(FD_ISSET(fd, &mux->rwant)) {
+			FD_SET(fd, rfds);
+			n = 1;
+		} else if(FD_ISSET(fd, &mux->ewant) && b->eof && b->n == 0) {
+			FD_SET(fd, efds);
+			n = 1;
+		}
+	}
+	FD_ZERO(&mux->rwant);
+	FD_ZERO(&mux->ewant);
+	return n;
+}
+
+static int timerreset;
+static int timerpid;
+
+static void
+alarmed(int v)
+{
+	timerreset = 1;
+}
+
+/* a little over an hour */
+#define LONGWAIT 4000001
+
+static void
+_killtimerproc(void)
+{
+	if(timerpid > 0)
+		kill(timerpid, SIGKILL);
+}
+
+static void
+_timerproc(void)
+{
+	int i;
+
+	if((timerpid = _RFORK(RFFDG|RFPROC|RFNOWAIT)) == 0){
+		/* timer process */
+		setpgid(getpid(), _muxsid);
+		signal(SIGALRM, alarmed);
+		for(i=0; i<OPEN_MAX; i++)
+				_CLOSE(i);
+		_RENDEZVOUS(1, 0);
+		for(;;) {
+			_SLEEP(mux->waittime);
+			if(timerreset) {
+				timerreset = 0;
+			} else {
+				lock(&mux->lock);
+				if(mux->selwait && mux->waittime != LONGWAIT) {
+					mux->selwait = 0;
+					mux->waittime = LONGWAIT;
+					unlock(&mux->lock);
+					_RENDEZVOUS((unsigned long)&mux->selwait, -2);
+				} else {
+					mux->waittime = LONGWAIT;
+					unlock(&mux->lock);
+				}
+			}
+		}
+	}
+	atexit(_killtimerproc);
+	/* parent process continues */
+	_RENDEZVOUS(1, 0);
+}
+
+static void
+_resettimer(void)
+{
+	kill(timerpid, SIGALRM);
+}
+
+void
+_killmuxsid(void)
+{
+	if(_muxsid != -1 && (_mainpid == getpid() || _mainpid == -1))
+		kill(-_muxsid,SIGTERM);
+}
+
+/* call this on fork(), because reading a BUFFERED fd won't work in child */
+void
+_detachbuf(void)
+{
+	int i;
+	Fdinfo *f;
+
+	if(mux == 0)
+		return;
+	_SEGDETACH(mux);
+	for(i = 0; i < OPEN_MAX; i++){
+		f = &_fdinfo[i];
+		if(f->flags&FD_BUFFERED)
+			f->flags = (f->flags&~FD_BUFFERED) | FD_BUFFEREDX;
+				/* mark 'poisoned' */
+	}
+	mux = 0;
+	_muxsid = -1;
+	_mainpid = -1;
+	timerpid = -1;
+}
+
+static int
+copynotehandler(void *u, char *msg)
+{
+	int i;
+	void(*f)(int);
+
+	if(_finishing)
+		_finish(0, 0);
+	_NOTED(1);
+}
diff --git a/sys/src/ape/lib/ap/plan9/_dirconv.c b/sys/src/ape/lib/ap/plan9/_dirconv.c
new file mode 100755
index 000000000..3889c2ee2
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_dirconv.c
@@ -0,0 +1,65 @@
+#include "lib.h"
+#include <string.h>
+#include "sys9.h"
+#include "dir.h"
+
+#define	CHAR(x)		*p++ = f->x
+#define	SHORT(x)	p[0] = f->x; p[1] = f->x>>8; p += 2
+#define	LONG(x)		p[0] = f->x; p[1] = f->x>>8; p[2] = f->x>>16; p[3] = f->x>>24; p += 4
+#define	VLONG(x)	p[0] = f->x; p[1] = f->x>>8; p[2] = f->x>>16; p[3] = f->x>>24;\
+			p[4] = 0; p[5] = 0; p[6] = 0; p[7] = 0; p += 8
+#define	STRING(x,n)	memcpy(p, f->x, n); p += n
+
+int
+convD2M(Dir *f, char *ap)
+{
+	unsigned char *p;
+
+	p = (unsigned char*)ap;
+	STRING(name, sizeof(f->name));
+	STRING(uid, sizeof(f->uid));
+	STRING(gid, sizeof(f->gid));
+	LONG(qid.path);
+	LONG(qid.vers);
+	LONG(mode);
+	LONG(atime);
+	LONG(mtime);
+	VLONG(length);
+	SHORT(type);
+	SHORT(dev);
+	return p - (unsigned char*)ap;
+}
+
+#undef	CHAR
+#undef	SHORT
+#undef	LONG
+#undef	VLONG
+#undef	STRING
+
+#define	CHAR(x)		f->x = *p++
+#define	SHORT(x)	f->x = (p[0] | (p[1]<<8)); p += 2
+#define	LONG(x)		f->x = (p[0] | (p[1]<<8) |\
+			(p[2]<<16) | (p[3]<<24)); p += 4
+#define	VLONG(x)	f->x = (p[0] | (p[1]<<8) |\
+			(p[2]<<16) | (p[3]<<24)); p += 8
+#define	STRING(x,n)	memcpy(f->x, p, n); p += n
+
+int
+convM2D(char *ap, Dir *f)
+{
+	unsigned char *p;
+
+	p = (unsigned char*)ap;
+	STRING(name, sizeof(f->name));
+	STRING(uid, sizeof(f->uid));
+	STRING(gid, sizeof(f->gid));
+	LONG(qid.path);
+	LONG(qid.vers);
+	LONG(mode);
+	LONG(atime);
+	LONG(mtime);
+	VLONG(length);
+	SHORT(type);
+	SHORT(dev);
+	return p - (unsigned char*)ap;
+}
diff --git a/sys/src/ape/lib/ap/plan9/_envsetup.c b/sys/src/ape/lib/ap/plan9/_envsetup.c
new file mode 100755
index 000000000..55cf33b85
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_envsetup.c
@@ -0,0 +1,123 @@
+#include "lib.h"
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include "sys9.h"
+#include "dir.h"
+
+/*
+ * Called before main to initialize environ.
+ * Some plan9 environment variables
+ * have 0 bytes in them (notably $path);
+ * we change them to 1's (and execve changes back)
+ *
+ * Also, register the note handler.
+ */
+
+char **environ;
+int errno;
+unsigned long _clock;
+static char name[NAME_MAX+5] = "#e";
+static void fdsetup(char *, char *);
+static void sigsetup(char *, char *);
+
+enum {
+	Envhunk=7000,
+};
+
+void
+_envsetup(void)
+{
+	int dfd;
+	struct dirent *de;
+	int n, nd, m, i, j, f;
+	int psize, cnt;
+	int nohandle;
+	int fdinited;
+	char *ps, *p;
+	char **pp;
+	Dir *d9, *d9a;
+
+	nohandle = 0;
+	fdinited = 0;
+	cnt = 0;
+	dfd = _OPEN(name, 0);
+	if(dfd < 0) {
+		static char **emptyenvp = 0;
+		environ = emptyenvp;
+		return;
+	}
+	name[2] = '/';
+	ps = p = malloc(Envhunk);
+	psize = Envhunk;
+	nd = _dirreadall(dfd, &d9a);
+	_CLOSE(dfd);
+	for(j=0; j<nd; j++){
+		d9 = &d9a[j];
+		n = strlen(d9->name);
+		m = d9->length;
+		i = p - ps;
+		if(i+n+1+m+1 > psize) {
+			psize += (n+m+2 < Envhunk)? Envhunk : n+m+2;
+			ps = realloc(ps, psize);
+			p = ps + i;
+		}
+		memcpy(p, d9->name, n);
+		p[n] = '=';
+		strcpy(name+3, d9->name);
+		f = _OPEN(name, O_RDONLY);
+		if(f < 0 || _READ(f, p+n+1, m) != m)
+			m = 0;
+		_CLOSE(f);
+		if(p[n+m] == 0)
+			m--;
+		for(i=0; i<m; i++)
+			if(p[n+1+i] == 0)
+				p[n+1+i] = 1;
+		p[n+1+m] = 0;
+		if(strcmp(d9->name, "_fdinfo") == 0) {
+			_fdinit(p+n+1, p+n+1+m);
+			fdinited = 1;
+		} else if(strcmp(d9->name, "_sighdlr") == 0)
+			sigsetup(p+n+1, p+n+1+m);
+		else if(strcmp(d9->name, "nohandle") == 0)
+			nohandle = 1;
+		p += n+m+2;
+		cnt++;
+	}
+	free(d9a);
+	if(!fdinited)
+		_fdinit(0, 0);
+	environ = pp = malloc((1+cnt)*sizeof(char *));
+	p = ps;
+	for(i = 0; i < cnt; i++) {
+		*pp++ = p;
+		p = memchr(p, 0, ps+psize-p);
+		if (!p)
+			break;
+		p++;
+	}
+	*pp = 0;
+	if(!nohandle)
+		_NOTIFY(_notehandler);
+}
+
+static void
+sigsetup(char *s, char *se)
+{
+	int i, sig;
+	char *e;
+
+	while(s < se){
+		sig = strtoul(s, &e, 10);
+		if(s == e)
+			break;
+		s = e;
+		if(sig <= MAXSIG)
+			_sighdlr[sig] = SIG_IGN;
+	}
+}
diff --git a/sys/src/ape/lib/ap/plan9/_errno.c b/sys/src/ape/lib/ap/plan9/_errno.c
new file mode 100755
index 000000000..8e5caad7d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_errno.c
@@ -0,0 +1,124 @@
+#include "lib.h"
+#include "sys9.h"
+#include <string.h>
+#include <errno.h>
+
+/* make this global, so programs can look at it if errno is unilluminating */
+
+/* see also: ../stdio/strerror.c, with errno-> string mapping */
+
+char _plan9err[ERRMAX];
+
+static struct errmap {
+	int	errno;
+	char	*ename;
+} map[] = {
+	/* from /sys/src/9/port/errstr.h */
+	{EINVAL,	"inconsistent mount"},
+	{EINVAL,	"not mounted"},
+	{EINVAL,	"not in union"},
+	{EIO,		"mount rpc error"},
+	{EIO,		"mounted device shut down"},
+	{EPERM,	"mounted directory forbids creation"},
+	{ENOENT,	"does not exist"},
+	{ENXIO,	"unknown device in # filename"},
+	{ENOTDIR,	"not a directory"},
+	{EISDIR,	"file is a directory"},
+	{EINVAL,	"bad character in file name"},
+	{EINVAL,	"file name syntax"},
+	{EPERM,	"permission denied"},
+	{EPERM,	"inappropriate use of fd"},
+	{EINVAL,	"bad arg in system call"},
+	{EBUSY,	"device or object already in use"},
+	{EIO,		"i/o error"},
+	{EIO,		"read or write too large"},
+	{EIO,		"read or write too small"},
+	{EADDRINUSE,	"network port not available"},
+	{ESHUTDOWN,	"write to hungup stream"},
+	{ESHUTDOWN,	"i/o on hungup channel"},
+	{EINVAL,	"bad process or channel control request"},
+	{EBUSY,	"no free devices"},
+	{ESRCH,		"process exited"},
+	{ECHILD,	"no living children"},
+	{EIO,		"i/o error in demand load"},
+	{ENOMEM,	"virtual memory allocation failed"},
+	{EBADF,	"fd out of range or not open"},
+	{EMFILE,	"no free file descriptors"},
+	{ESPIPE,	"seek on a stream"},
+	{ENOEXEC,	"exec header invalid"},
+	{ETIMEDOUT,	"connection timed out"},
+	{ECONNREFUSED,	"connection refused"},
+	{ECONNREFUSED,	"connection in use"},
+	{EINTR,		"interrupted"},
+	{ENOMEM,	"kernel allocate failed"},
+	{EINVAL,	"segments overlap"},
+	{EIO,		"i/o count too small"},
+	{EGREG,	"ken has left the building"},
+	{EINVAL,	"bad attach specifier"},
+
+	/* from exhausted() calls in kernel */
+	{ENFILE,	"no free file descriptors"},
+	{EBUSY,	"no free mount devices"},
+	{EBUSY,	"no free mount rpc buffer"},
+	{EBUSY,		"no free segments"},
+	{ENOMEM,	"no free memory"},
+	{ENOBUFS,	"no free Blocks"},
+	{EBUSY,	"no free routes"},
+
+	/* from ken */
+	{EINVAL,	"attach -- bad specifier"},
+	{EBADF,		"unknown fid"},
+	{EINVAL,	"bad character in directory name"},
+	{EBADF,		"read/write -- on non open fid"},
+	{EIO,		"read/write -- count too big"},
+	{EIO,		"phase error -- directory entry not allocated"},
+	{EIO,		"phase error -- qid does not match"},
+	{EACCES,	"access permission denied"},
+	{ENOENT,	"directory entry not found"},
+	{EINVAL,	"open/create -- unknown mode"},
+	{ENOTDIR,	"walk -- in a non-directory"},
+	{ENOTDIR,	"create -- in a non-directory"},
+	{EIO,		"phase error -- cannot happen"},
+	{EEXIST,	"create -- file exists"},
+	{EINVAL,	"create -- . and .. illegal names"},
+	{ENOTEMPTY,	"directory not empty"},
+	{EINVAL,	"attach -- privileged user"},
+	{EPERM,		"wstat -- not owner"},
+	{EPERM,		"wstat -- not in group"},
+	{EINVAL,	"create/wstat -- bad character in file name"},
+	{EBUSY,		"walk -- too many (system wide)"},
+	{EROFS,		"file system read only"},
+	{ENOSPC,	"file system full"},
+	{EINVAL,	"read/write -- offset negative"},
+	{EBUSY,		"open/create -- file is locked"},
+	{EBUSY,		"close/read/write -- lock is broken"},
+
+	/* from sockets */
+	{ENOTSOCK,	"not a socket"},
+	{EPROTONOSUPPORT,	"protocol not supported"},
+	{ECONNREFUSED,	"connection refused"},
+	{EAFNOSUPPORT,	"address family not supported"},
+	{ENOBUFS,	"insufficient buffer space"},
+	{EOPNOTSUPP,	"operation not supported"},
+	{EADDRINUSE,	"address in use"},
+	{EGREG,		"unnamed error message"},
+};
+
+#define NERRMAP	(sizeof(map)/sizeof(struct errmap))
+
+/* convert last system call error to an errno */
+void
+_syserrno(void)
+{
+	int i;
+
+	if(_ERRSTR(_plan9err, sizeof _plan9err) < 0)
+		errno = EINVAL;
+	else{
+		for(i = 0; i < NERRMAP; i++)
+			if(strstr(_plan9err, map[i].ename) != 0)
+				break;
+		_ERRSTR(_plan9err, sizeof _plan9err);
+		errno = (i < NERRMAP)? map[i].errno : EINVAL;
+	}
+}
diff --git a/sys/src/ape/lib/ap/plan9/_exit.c b/sys/src/ape/lib/ap/plan9/_exit.c
new file mode 100755
index 000000000..e3886ff18
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_exit.c
@@ -0,0 +1,58 @@
+#include "lib.h"
+#include "sys9.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+
+int _finishing = 0;
+int _sessleader = 0;
+
+static char exitstatus[ERRMAX];
+
+void
+_exit(int status)
+{
+	_finish(status, 0);
+}
+
+void
+_finish(int status, char *term)
+{
+	int i, nalive;
+	char *cp;
+
+	if(_finishing)
+		_EXITS(exitstatus);
+	_finishing = 1;
+	if(status){
+		cp = _ultoa(exitstatus, status & 0xFF);
+		*cp = 0;
+	}else if(term){
+		strncpy(exitstatus, term, ERRMAX);
+		exitstatus[ERRMAX-1] = '\0';
+	}
+	if(_sessleader)
+		kill(0, SIGTERM);
+	_EXITS(exitstatus);
+}
+
+/* emulate: return p+sprintf(p, "%uld", v) */
+#define IDIGIT 15
+char *
+_ultoa(char *p, unsigned long v)
+{
+	char s[IDIGIT];
+	int n, i;
+
+	s[IDIGIT-1] = 0;
+	for(i = IDIGIT-2; i; i--){
+		n = v % 10;
+		s[i] = n + '0';
+		v = v / 10;
+		if(v == 0)
+			break;
+	}
+	strcpy(p, s+i);
+	return p + (IDIGIT-1-i);
+}
diff --git a/sys/src/ape/lib/ap/plan9/_fcall.c b/sys/src/ape/lib/ap/plan9/_fcall.c
new file mode 100755
index 000000000..394f4cc08
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_fcall.c
@@ -0,0 +1,422 @@
+#include	<string.h>
+#include	"sys9.h"
+#include	"lib.h"
+#include	"dir.h"
+#include	"fcall.h"
+
+typedef unsigned char uchar;
+
+#define	CHAR(x)		*p++ = f->x
+#define	SHORT(x)	p[0] = f->x; p[1] = f->x>>8; p += 2
+#define	LONG(x)		p[0] = f->x; p[1] = f->x>>8; p[2] = f->x>>16; p[3] = f->x>>24; p += 4
+#define	VLONG(x)	p[0] = f->x; p[1] = f->x>>8; p[2] = f->x>>16; p[3] = f->x>>24;\
+				p[4] = 0; p[5] = 0; p[6] = 0; p[7] = 0; p += 8
+#define	STRING(x,n)	memcpy(p, f->x, n); p += n
+
+int
+convS2M(Fcall *f, char *ap)
+{
+	uchar *p;
+
+	p = (uchar*)ap;
+	CHAR(type);
+	SHORT(tag);
+	switch(f->type)
+	{
+	default:
+		return 0;
+
+	case Tosession:
+	case Tnop:
+		break;
+
+	case Tsession:
+		STRING(chal, sizeof(f->chal));
+		break;
+
+	case Tflush:
+		SHORT(oldtag);
+		break;
+
+	case Tattach:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(aname, sizeof(f->aname));
+		STRING(ticket, sizeof(f->ticket));
+		STRING(auth, sizeof(f->auth));
+		break;
+
+	case Toattach:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(aname, sizeof(f->aname));
+		STRING(ticket, NAMELEN);
+		break;
+
+	case Tauth:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(ticket, 8+NAMELEN);
+		break;
+
+	case Tclone:
+		SHORT(fid);
+		SHORT(newfid);
+		break;
+
+	case Twalk:
+		SHORT(fid);
+		STRING(name, sizeof(f->name));
+		break;
+
+	case Topen:
+		SHORT(fid);
+		CHAR(mode);
+		break;
+
+	case Tcreate:
+		SHORT(fid);
+		STRING(name, sizeof(f->name));
+		LONG(perm);
+		CHAR(mode);
+		break;
+
+	case Tread:
+		SHORT(fid);
+		VLONG(offset);
+		SHORT(count);
+		break;
+
+	case Twrite:
+		SHORT(fid);
+		VLONG(offset);
+		SHORT(count);
+		p++;	/* pad(1) */
+		STRING(data, f->count);
+		break;
+
+	case Tclunk:
+		SHORT(fid);
+		break;
+
+	case Tremove:
+		SHORT(fid);
+		break;
+
+	case Tstat:
+		SHORT(fid);
+		break;
+
+	case Twstat:
+		SHORT(fid);
+		STRING(stat, sizeof(f->stat));
+		break;
+
+	case Tclwalk:
+		SHORT(fid);
+		SHORT(newfid);
+		STRING(name, sizeof(f->name));
+		break;
+/*
+ */
+	case Rosession:
+	case Rnop:
+		break;
+
+	case Rsession:
+		STRING(chal, sizeof(f->chal));
+		STRING(authid, sizeof(f->authid));
+		STRING(authdom, sizeof(f->authdom));
+		break;
+
+	case Rerror:
+		STRING(ename, sizeof(f->ename));
+		break;
+
+	case Rflush:
+		break;
+
+	case Rattach:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		STRING(rauth, sizeof(f->rauth));
+		break;
+
+	case Roattach:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rauth:
+		SHORT(fid);
+		STRING(ticket, 8+8+7+7);
+		break;
+
+	case Rclone:
+		SHORT(fid);
+		break;
+
+	case Rwalk:
+	case Rclwalk:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Ropen:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rcreate:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rread:
+		SHORT(fid);
+		SHORT(count);
+		p++;	/* pad(1) */
+		STRING(data, f->count);
+		break;
+
+	case Rwrite:
+		SHORT(fid);
+		SHORT(count);
+		break;
+
+	case Rclunk:
+		SHORT(fid);
+		break;
+
+	case Rremove:
+		SHORT(fid);
+		break;
+
+	case Rstat:
+		SHORT(fid);
+		STRING(stat, sizeof(f->stat));
+		break;
+
+	case Rwstat:
+		SHORT(fid);
+		break;
+	}
+	return p - (uchar*)ap;
+}
+
+#undef	CHAR
+#undef	SHORT
+#undef	LONG
+#undef	VLONG
+#undef	STRING
+
+#define	CHAR(x)		f->x = *p++
+#define	SHORT(x)	f->x = (p[0] | (p[1]<<8)); p += 2
+#define	LONG(x)		f->x = (p[0] | (p[1]<<8) |\
+				(p[2]<<16) | (p[3]<<24)); p += 4
+#define	VLONG(x)	f->x = (p[0] | (p[1]<<8) |\
+				(p[2]<<16) | (p[3]<<24)); p += 8
+#define	STRING(x,n)	memcpy(f->x, p, n); p += n
+
+int
+convM2S(char *ap, Fcall *f, int n)
+{
+	uchar *p;
+
+	p = (uchar*)ap;
+	CHAR(type);
+	SHORT(tag);
+	switch(f->type)
+	{
+	default:
+		return 0;
+
+	case Tnop:
+	case Tosession:
+		break;
+
+	case Tsession:
+		STRING(chal, sizeof(f->chal));
+		break;
+
+	case Tflush:
+		SHORT(oldtag);
+		break;
+
+	case Tattach:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(aname, sizeof(f->aname));
+		STRING(ticket, sizeof(f->ticket));
+		STRING(auth, sizeof(f->auth));
+		break;
+
+	case Toattach:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(aname, sizeof(f->aname));
+		STRING(ticket, NAMELEN);
+		break;
+
+	case Tauth:
+		SHORT(fid);
+		STRING(uname, sizeof(f->uname));
+		STRING(ticket, 8+NAMELEN);
+		break;
+
+	case Tclone:
+		SHORT(fid);
+		SHORT(newfid);
+		break;
+
+	case Twalk:
+		SHORT(fid);
+		STRING(name, sizeof(f->name));
+		break;
+
+	case Topen:
+		SHORT(fid);
+		CHAR(mode);
+		break;
+
+	case Tcreate:
+		SHORT(fid);
+		STRING(name, sizeof(f->name));
+		LONG(perm);
+		CHAR(mode);
+		break;
+
+	case Tread:
+		SHORT(fid);
+		VLONG(offset);
+		SHORT(count);
+		break;
+
+	case Twrite:
+		SHORT(fid);
+		VLONG(offset);
+		SHORT(count);
+		p++;	/* pad(1) */
+		f->data = (char*)p; p += f->count;
+		break;
+
+	case Tclunk:
+		SHORT(fid);
+		break;
+
+	case Tremove:
+		SHORT(fid);
+		break;
+
+	case Tstat:
+		SHORT(fid);
+		break;
+
+	case Twstat:
+		SHORT(fid);
+		STRING(stat, sizeof(f->stat));
+		break;
+
+	case Tclwalk:
+		SHORT(fid);
+		SHORT(newfid);
+		STRING(name, sizeof(f->name));
+		break;
+/*
+ */
+	case Rnop:
+	case Rosession:
+		break;
+
+	case Rsession:
+		STRING(chal, sizeof(f->chal));
+		STRING(authid, sizeof(f->authid));
+		STRING(authdom, sizeof(f->authdom));
+		break;
+
+	case Rerror:
+		STRING(ename, sizeof(f->ename));
+		break;
+
+	case Rflush:
+		break;
+
+	case Rattach:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		STRING(rauth, sizeof(f->rauth));
+		break;
+
+	case Roattach:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rauth:
+		SHORT(fid);
+		STRING(ticket, 8+8+7+7);
+		break;
+
+	case Rclone:
+		SHORT(fid);
+		break;
+
+	case Rwalk:
+	case Rclwalk:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Ropen:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rcreate:
+		SHORT(fid);
+		LONG(qid.path);
+		LONG(qid.vers);
+		break;
+
+	case Rread:
+		SHORT(fid);
+		SHORT(count);
+		p++;	/* pad(1) */
+		f->data = (char*)p; p += f->count;
+		break;
+
+	case Rwrite:
+		SHORT(fid);
+		SHORT(count);
+		break;
+
+	case Rclunk:
+		SHORT(fid);
+		break;
+
+	case Rremove:
+		SHORT(fid);
+		break;
+
+	case Rstat:
+		SHORT(fid);
+		STRING(stat, sizeof(f->stat));
+		break;
+
+	case Rwstat:
+		SHORT(fid);
+		break;
+	}
+	if((uchar*)ap+n == p)
+		return n;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/_fdinfo.c b/sys/src/ape/lib/ap/plan9/_fdinfo.c
new file mode 100755
index 000000000..85bbeca95
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_fdinfo.c
@@ -0,0 +1,169 @@
+#define  _BSDTIME_EXTENSION
+#include "lib.h"
+#include <sys/stat.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include <string.h>
+
+extern int errno;
+Fdinfo _fdinfo[OPEN_MAX];
+
+/*
+   called from _envsetup, either with the value of the environment
+   variable _fdinfo (from s to se-1), or with s==0 if there was no _fdinfo
+*/
+static void
+defaultfdinit(void)
+{
+	int i;
+	Fdinfo *fi;
+
+	for(i = 0; i <= 2; i++) {
+		fi = &_fdinfo[i];
+		fi->flags = FD_ISOPEN;
+		fi->oflags = (i == 0)? O_RDONLY : O_WRONLY;
+		if(_isatty(i))
+			fi->flags |= FD_ISTTY;
+	}
+}
+
+static int
+readprocfdinit(void)
+{
+	/* construct info from /proc/$pid/fd */
+	char buf[8192];
+	Fdinfo *fi;
+	int fd, pfd, pid, n, tot, m;
+	char *s, *nexts;
+
+	memset(buf, 0, sizeof buf);
+	pfd = _OPEN("#c/pid", 0);
+	if(pfd < 0)
+		return -1;
+	if(_PREAD(pfd, buf, 100, 0) < 0){
+		_CLOSE(pfd);
+		return -1;
+	}
+	_CLOSE(pfd);
+	pid = strtoul(buf, 0, 10);
+	strcpy(buf, "#p/");
+	_ultoa(buf+3, pid);
+	strcat(buf, "/fd");
+	pfd = _OPEN(buf, 0);
+	if(pfd < 0)
+		return -1;
+	memset(buf, 0, sizeof buf);
+	tot = 0;
+	for(;;){
+		n = _PREAD(pfd, buf+tot, sizeof buf-tot, tot);
+		if(n <= 0)
+			break;
+		tot += n;
+	}
+	_CLOSE(pfd);
+	if(n < 0)
+		return -1;
+	buf[sizeof buf-1] = '\0';
+	s = strchr(buf, '\n');	/* skip current directory */
+	if(s == 0)
+		return -1;
+	s++;
+	m = 0;
+	for(; s && *s; s=nexts){
+		nexts = strchr(s, '\n');
+		if(nexts)
+			*nexts++ = '\0';
+		errno = 0;
+		fd = strtoul(s, &s, 10);
+		if(errno != 0)
+			return -1;
+		if(fd >= OPEN_MAX)
+			continue;
+		if(fd == pfd)
+			continue;
+		fi = &_fdinfo[fd];
+		fi->flags = FD_ISOPEN;
+		while(*s == ' ' || *s == '\t')
+			s++;
+		if(*s == 'r'){
+			m |= 1;
+			s++;
+		}
+		if(*s == 'w'){
+			m |= 2;
+		}
+		if(m==1)
+			fi->oflags = O_RDONLY;
+		else if(m==2)
+			fi->oflags = O_WRONLY;
+		else
+			fi->oflags = O_RDWR;
+		if(strlen(s) >= 9 && strcmp(s+strlen(s)-9, "/dev/cons") == 0)
+			fi->flags |= FD_ISTTY;
+	}
+	return 0;
+}
+
+static void
+sfdinit(int usedproc, char *s, char *se)
+{
+	int i;
+	Fdinfo *fi;
+	unsigned long fd, fl, ofl;
+	char *e;
+	struct stat sbuf;
+
+	while(s < se){
+		fd = strtoul(s, &e, 10);
+		if(s == e)
+			break;
+		s = e;
+		fl = strtoul(s, &e, 10);
+		if(s == e)
+			break;
+		s = e;
+		ofl = strtoul(s, &e, 10);
+		if(s == e)
+			break;
+		s = e;
+		if(fd < OPEN_MAX){
+			fi = &_fdinfo[fd];
+			if(usedproc && !(fi->flags&FD_ISOPEN))
+				continue;	/* should probably ignore all of $_fdinit */
+			fi->flags = fl;
+			fi->oflags = ofl;
+			if(_isatty(fd))
+				fi->flags |= FD_ISTTY;
+		}
+	}
+
+}
+
+void
+_fdinit(char *s, char *se)
+{
+	int i, usedproc;
+	Fdinfo *fi;
+	struct stat sbuf;
+
+	usedproc = 0;
+	if(readprocfdinit() == 0)
+		usedproc = 1;
+else
+_WRITE(2, "FAILED\n", 7);
+	if(s)
+		sfdinit(usedproc, s, se);
+	if(!s && !usedproc)
+		defaultfdinit();
+
+	for(i = 0; i < OPEN_MAX; i++) {
+		fi = &_fdinfo[i];
+		if(fi->flags&FD_ISOPEN){
+			if(fstat(i, &sbuf) >= 0) {
+				fi->uid = sbuf.st_uid;
+				fi->gid = sbuf.st_gid;
+			}
+		}
+	}
+}
+
diff --git a/sys/src/ape/lib/ap/plan9/_getpw.c b/sys/src/ape/lib/ap/plan9/_getpw.c
new file mode 100755
index 000000000..151d7f3c8
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_getpw.c
@@ -0,0 +1,174 @@
+#include "lib.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "sys9.h"
+#include "dir.h"
+
+/*
+ * Search /adm/users for line with second field ==  *pname (if
+ * not NULL), else with first field == *pnum.  Return non-zero
+ * if found, and fill in *pnum, *pname, and *plist to fields
+ * 1, 2, and 4
+ */
+
+enum {NAMEMAX = 20, MEMOMAX = 40 };
+
+static char *admusers = "/adm/users";
+
+/* we hold a fixed-length memo list of past lookups, and use a move-to-front
+    strategy to organize the list
+*/
+typedef struct Memo {
+	char		name[NAMEMAX];
+	int		num;
+	char		*glist;
+} Memo;
+
+static Memo *memo[MEMOMAX];
+static int nmemo = 0;
+
+int
+_getpw(int *pnum, char **pname, char **plist)
+{
+	Dir *d;
+	int f, n, i, j, matchnum, m, matched;
+	char *eline, *f1, *f2, *f3, *f4;
+	Memo *mem;
+	static char *au = NULL;
+	vlong length;
+
+	if(!pname)
+		return 0;
+	if(au == NULL){
+		d = _dirstat(admusers);
+		if(d == nil)
+			return 0;
+		length = d->length;
+		free(d);
+		if((au = (char *)malloc(length+2)) == NULL)
+			return 0;
+		f = open(admusers, O_RDONLY);
+		if(f < 0)
+			return 0;
+		n = read(f, au, length);
+		if(n < 0)
+			return 0;
+		au[n] = 0;
+	}
+	matchnum = (*pname == NULL);
+	matched = 0;
+	/* try using memo */
+	for(i = 0; i<nmemo; i++) {
+		mem = memo[i];
+		if(matchnum)
+			matched = (mem->num == *pnum);
+		else
+			matched = (strcmp(mem->name, *pname) == 0);
+		if(matched) {
+			break;
+		}
+	}
+	if(!matched)
+		for(f1 = au, eline = au; !matched && *eline; f1 = eline+1){
+			eline = strchr(f1, '\n');
+			if(!eline)
+				eline = strchr(f1, 0);
+			if(*f1 == '#' || *f1 == '\n')
+				continue;
+			n = eline-f1;
+			f2 = memchr(f1, ':', n);
+			if(!f2)
+				continue;
+			f2++;
+			f3 = memchr(f2, ':', n-(f2-f1));
+			if(!f3)
+				continue;
+			f3++;
+			f4 = memchr(f3, ':', n-(f3-f1));
+			if(!f4)
+				continue;
+			f4++;
+			if(matchnum)
+				matched = (atoi(f1) == *pnum);
+			else{
+				int length;
+
+				length = f3-f2-1;
+				matched = length==strlen(*pname) && memcmp(*pname, f2, length)==0;
+			}
+			if(matched){
+				/* allocate and fill in a Memo structure */
+				mem = (Memo*)malloc(sizeof(struct Memo));
+				if(!mem)
+					return 0;
+				m = (f3-f2)-1;
+				if(m > NAMEMAX-1)
+					m = NAMEMAX-1;
+				memcpy(mem->name, f2, m);
+				mem->name[m] = 0;
+				mem->num = atoi(f1);
+				m = n-(f4-f1);
+				if(m > 0){
+					mem->glist = (char*)malloc(m+1);
+					if(mem->glist) {
+						memcpy(mem->glist, f4, m);
+						mem->glist[m] = 0;
+					}
+				} else
+					mem->glist = 0;
+				/* prepare for following move-to-front */
+				if(nmemo == MEMOMAX) {
+					free(memo[nmemo-1]);
+					i = nmemo-1;
+				} else {
+					i = nmemo++;
+				}
+			}
+		}
+	if(matched) {
+		if(matchnum)
+			*pname = mem->name;
+		else
+			*pnum = mem->num;
+		if(plist)
+			*plist = mem->glist;
+		if(i > 0) {
+			/* make room at front */
+			for(j = i; j > 0; j--)
+				memo[j] = memo[j-1];
+		}
+		memo[0] = mem;
+		return 1;
+	}
+	return 0;
+}
+
+char **
+_grpmems(char *list)
+{
+	char **v;
+	char *p;
+	static char *holdvec[200];
+	static char holdlist[1000];
+
+	p = list;
+	v = holdvec;
+	if(p) {
+		strncpy(holdlist, list, sizeof(holdlist));
+		while(v< &holdvec[sizeof(holdvec)]-1 && *p){
+			*v++ = p;
+			p = strchr(p, ',');
+			if(p){
+				p++;
+				*p = 0;
+			}else
+				break;
+		}
+	}
+	*v = 0;
+	return holdvec;
+}
diff --git a/sys/src/ape/lib/ap/plan9/_nap.c b/sys/src/ape/lib/ap/plan9/_nap.c
new file mode 100755
index 000000000..d21eff79c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/_nap.c
@@ -0,0 +1,20 @@
+#include "lib.h"
+#include <unistd.h>
+#include <time.h>
+#include "sys9.h"
+
+/*
+ * This is an extension to POSIX
+ */
+unsigned int
+_nap(unsigned int millisecs)
+{
+	time_t t0, t1;
+
+	t0 = time(0);
+	if(_SLEEP(millisecs) < 0){
+		t1 = time(0);
+		return t1-t0;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/access.c b/sys/src/ape/lib/ap/plan9/access.c
new file mode 100755
index 000000000..c51b37d6c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/access.c
@@ -0,0 +1,62 @@
+#include "lib.h"
+#include <string.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+access(const char *name, int mode)
+{
+	int fd, n;
+	Dir *db;
+	struct stat st;
+	static char omode[] = {
+		0,
+		3,
+		1,
+		2,
+		0,
+		2,
+		2,
+		2
+	};
+	char tname[1024];
+
+	if(mode == 0){
+		db = _dirstat(name);
+		if(db == nil){
+			_syserrno();
+			return -1;
+		}
+		free(db);
+		return 0;
+	}
+	fd = open(name, omode[mode&7]);
+	if(fd >= 0){
+		close(fd);
+		return 0;
+	}
+	else if(stat(name, &st)==0 && S_ISDIR(st.st_mode)){
+		if(mode & (R_OK|X_OK)){
+			fd = open(name, O_RDONLY);
+			if(fd < 0)
+				return -1;
+			close(fd);
+		}
+		if(mode & W_OK){
+			strncpy(tname, name, sizeof(tname)-9);
+			strcat(tname, "/_AcChAcK");
+			fd = creat(tname, 0666);
+			if(fd < 0)
+				return -1;
+			close(fd);
+			_REMOVE(tname);
+		}
+		return 0;
+	}
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/acid.c b/sys/src/ape/lib/ap/plan9/acid.c
new file mode 100755
index 000000000..5109a215e
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/acid.c
@@ -0,0 +1,31 @@
+/* include struct defs to get acid library 
+	cpp -I/sys/include/ape -I/$objtype/include/ape -I./include  acid.c > t.c
+	vc -a t.c > acidlib
+*/
+#define _POSIX_SOURCE 1
+#define _BSD_EXTENSION 1
+#define _LOCK_EXTENSION
+#include <stddef.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <lock.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <termios.h>
+#include <stdarg.h>
+#include <math.h>
+#include <float.h>
+#include <sys/utsname.h>
+/* #include "lib.h" buf.c below */
+/* #include "sys9.h" buf.c below */
+#include "_buf.c"
+#include "dir.h"
+#include "fcall.h"
diff --git a/sys/src/ape/lib/ap/plan9/acidlib b/sys/src/ape/lib/ap/plan9/acidlib
new file mode 100755
index 000000000..a4f14503f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/acidlib
@@ -0,0 +1,706 @@
+sizeof_1_ = 8;
+aggr _1_
+{
+	'D' 0 quot;
+	'D' 4 rem;
+};
+
+defn
+_1_(addr) {
+	complex _1_ addr;
+	print("	quot	", addr.quot, "\n");
+	print("	rem	", addr.rem, "\n");
+};
+
+sizeof_2_ = 8;
+aggr _2_
+{
+	'D' 0 quot;
+	'D' 4 rem;
+};
+
+defn
+_2_(addr) {
+	complex _2_ addr;
+	print("	quot	", addr.quot, "\n");
+	print("	rem	", addr.rem, "\n");
+};
+
+sizeofsigaction = 12;
+aggr sigaction
+{
+	'X' 0 sa_handler;
+	'D' 4 sa_mask;
+	'D' 8 sa_flags;
+};
+
+defn
+sigaction(addr) {
+	complex sigaction addr;
+	print("	sa_handler	", addr.sa_handler\X, "\n");
+	print("	sa_mask	", addr.sa_mask, "\n");
+	print("	sa_flags	", addr.sa_flags, "\n");
+};
+
+sizeof_3_ = 32;
+aggr _3_
+{
+	'D' 0 fd;
+	'C' 4 flags;
+	'C' 5 state;
+	'X' 8 buf;
+	'X' 12 rp;
+	'X' 16 wp;
+	'X' 20 lp;
+	'U' 24 bufl;
+	'a' 28 unbuf;
+};
+
+defn
+_3_(addr) {
+	complex _3_ addr;
+	print("	fd	", addr.fd, "\n");
+	print("	flags	", addr.flags, "\n");
+	print("	state	", addr.state, "\n");
+	print("	buf	", addr.buf\X, "\n");
+	print("	rp	", addr.rp\X, "\n");
+	print("	wp	", addr.wp\X, "\n");
+	print("	lp	", addr.lp\X, "\n");
+	print("	bufl	", addr.bufl, "\n");
+	print("	unbuf	", addr.unbuf, "\n");
+};
+
+sizeof_4_ = 4;
+aggr _4_
+{
+	'D' 0 val;
+};
+
+defn
+_4_(addr) {
+	complex _4_ addr;
+	print("	val	", addr.val, "\n");
+};
+
+sizeoftimeval = 8;
+aggr timeval
+{
+	'D' 0 tv_sec;
+	'D' 4 tv_usec;
+};
+
+defn
+timeval(addr) {
+	complex timeval addr;
+	print("	tv_sec	", addr.tv_sec, "\n");
+	print("	tv_usec	", addr.tv_usec, "\n");
+};
+
+sizeoftimezone = 8;
+aggr timezone
+{
+	'D' 0 tz_minuteswest;
+	'D' 4 tz_dsttime;
+};
+
+defn
+timezone(addr) {
+	complex timezone addr;
+	print("	tz_minuteswest	", addr.tz_minuteswest, "\n");
+	print("	tz_dsttime	", addr.tz_dsttime, "\n");
+};
+
+sizeoffd_set = 12;
+aggr fd_set
+{
+	'a' 0 fds_bits;
+};
+
+defn
+fd_set(addr) {
+	complex fd_set addr;
+	mem(addr, "3X");
+};
+
+sizeofstat = 28;
+aggr stat
+{
+	'u' 0 st_dev;
+	'u' 2 st_ino;
+	'u' 4 st_mode;
+	'd' 6 st_nlink;
+	'd' 8 st_uid;
+	'd' 10 st_gid;
+	'D' 12 st_size;
+	'D' 16 st_atime;
+	'D' 20 st_mtime;
+	'D' 24 st_ctime;
+};
+
+defn
+stat(addr) {
+	complex stat addr;
+	print("	st_dev	", addr.st_dev, "\n");
+	print("	st_ino	", addr.st_ino, "\n");
+	print("	st_mode	", addr.st_mode, "\n");
+	print("	st_nlink	", addr.st_nlink, "\n");
+	print("	st_uid	", addr.st_uid, "\n");
+	print("	st_gid	", addr.st_gid, "\n");
+	print("	st_size	", addr.st_size, "\n");
+	print("	st_atime	", addr.st_atime, "\n");
+	print("	st_mtime	", addr.st_mtime, "\n");
+	print("	st_ctime	", addr.st_ctime, "\n");
+};
+
+sizeofflock = 16;
+aggr flock
+{
+	'd' 0 l_type;
+	'd' 2 l_whence;
+	'D' 4 l_start;
+	'D' 8 l_len;
+	'D' 12 l_pid;
+};
+
+defn
+flock(addr) {
+	complex flock addr;
+	print("	l_type	", addr.l_type, "\n");
+	print("	l_whence	", addr.l_whence, "\n");
+	print("	l_start	", addr.l_start, "\n");
+	print("	l_len	", addr.l_len, "\n");
+	print("	l_pid	", addr.l_pid, "\n");
+};
+
+sizeofdirent = 28;
+aggr dirent
+{
+	'a' 0 d_name;
+};
+
+defn
+dirent(addr) {
+	complex dirent addr;
+	print("	d_name	", addr.d_name, "\n");
+};
+
+sizeof_dirdesc = 16;
+aggr _dirdesc
+{
+	'D' 0 dd_fd;
+	'D' 4 dd_loc;
+	'D' 8 dd_size;
+	'X' 12 dd_buf;
+};
+
+defn
+_dirdesc(addr) {
+	complex _dirdesc addr;
+	print("	dd_fd	", addr.dd_fd, "\n");
+	print("	dd_loc	", addr.dd_loc, "\n");
+	print("	dd_size	", addr.dd_size, "\n");
+	print("	dd_buf	", addr.dd_buf\X, "\n");
+};
+
+sizeoftermios = 28;
+aggr termios
+{
+	'U' 0 c_iflag;
+	'U' 4 c_oflag;
+	'U' 8 c_cflag;
+	'U' 12 c_lflag;
+	'a' 16 c_cc;
+};
+
+defn
+termios(addr) {
+	complex termios addr;
+	print("	c_iflag	", addr.c_iflag, "\n");
+	print("	c_oflag	", addr.c_oflag, "\n");
+	print("	c_cflag	", addr.c_cflag, "\n");
+	print("	c_lflag	", addr.c_lflag, "\n");
+	print("	c_cc	", addr.c_cc, "\n");
+};
+
+sizeofutsname = 20;
+aggr utsname
+{
+	'X' 0 sysname;
+	'X' 4 nodename;
+	'X' 8 release;
+	'X' 12 version;
+	'X' 16 machine;
+};
+
+defn
+utsname(addr) {
+	complex utsname addr;
+	print("	sysname	", addr.sysname\X, "\n");
+	print("	nodename	", addr.nodename\X, "\n");
+	print("	release	", addr.release\X, "\n");
+	print("	version	", addr.version\X, "\n");
+	print("	machine	", addr.machine\X, "\n");
+};
+
+sizeofMuxbuf = 16400;
+aggr Muxbuf
+{
+	'D' 0 n;
+	'X' 4 putnext;
+	'X' 8 getnext;
+	'b' 12 fd;
+	'b' 13 eof;
+	'b' 14 roomwait;
+	'b' 15 datawait;
+	'a' 16 data;
+};
+
+defn
+Muxbuf(addr) {
+	complex Muxbuf addr;
+	print("	n	", addr.n, "\n");
+	print("	putnext	", addr.putnext\X, "\n");
+	print("	getnext	", addr.getnext\X, "\n");
+	print("	fd	", addr.fd, "\n");
+	print("	eof	", addr.eof, "\n");
+	print("	roomwait	", addr.roomwait, "\n");
+	print("	datawait	", addr.datawait, "\n");
+	print("	data	", addr.data, "\n");
+};
+
+sizeofFdinfo = 16;
+aggr Fdinfo
+{
+	'U' 0 flags;
+	'U' 4 oflags;
+	'X' 8 name;
+	'A' Muxbuf 12 buf;
+};
+
+defn
+Fdinfo(addr) {
+	complex Fdinfo addr;
+	print("	flags	", addr.flags, "\n");
+	print("	oflags	", addr.oflags, "\n");
+	print("	name	", addr.name\X, "\n");
+	print("	buf	", addr.buf\X, "\n");
+};
+
+sizeofWaitmsg = 112;
+aggr Waitmsg
+{
+	'a' 0 pid;
+	'a' 12 time;
+	'a' 48 msg;
+};
+
+defn
+Waitmsg(addr) {
+	complex Waitmsg addr;
+	print("	pid	", addr.pid, "\n");
+	print("	time	", addr.time, "\n");
+	print("	msg	", addr.msg, "\n");
+};
+
+sizeof_5_ = 8;
+aggr _5_
+{
+	'D' 0 hlength;
+	'D' 4 length;
+};
+
+defn
+_5_(addr) {
+	complex _5_ addr;
+	print("	hlength	", addr.hlength, "\n");
+	print("	length	", addr.length, "\n");
+};
+
+sizeof_6_ = 8;
+aggr _6_
+{
+	'a' 0 clength;
+	'D' 0 vlength;
+	{
+	'D' 0 hlength;
+	'D' 4 length;
+	};
+};
+
+defn
+_6_(addr) {
+	complex _6_ addr;
+	print("	clength	", addr.clength, "\n");
+	print("	vlength	", addr.vlength, "\n");
+	print("_5_ {\n");
+		_5_(addr+0);
+	print("}\n");
+};
+
+sizeofQid = 8;
+aggr Qid
+{
+	'U' 0 path;
+	'U' 4 vers;
+};
+
+defn
+Qid(addr) {
+	complex Qid addr;
+	print("	path	", addr.path, "\n");
+	print("	vers	", addr.vers, "\n");
+};
+
+sizeofDir = 116;
+aggr Dir
+{
+	'a' 0 name;
+	'a' 28 uid;
+	'a' 56 gid;
+	Qid 84 qid;
+	'U' 92 mode;
+	'D' 96 atime;
+	'D' 100 mtime;
+	{
+	'a' 104 clength;
+	'D' 104 vlength;
+	{
+	'D' 104 hlength;
+	'D' 108 length;
+	};
+	};
+	'd' 112 type;
+	'd' 114 dev;
+};
+
+defn
+Dir(addr) {
+	complex Dir addr;
+	print("	name	", addr.name, "\n");
+	print("	uid	", addr.uid, "\n");
+	print("	gid	", addr.gid, "\n");
+	print("Qid qid {\n");
+	Qid(addr.qid);
+	print("}\n");
+	print("	mode	", addr.mode, "\n");
+	print("	atime	", addr.atime, "\n");
+	print("	mtime	", addr.mtime, "\n");
+	print("_6_ {\n");
+		_6_(addr+104);
+	print("}\n");
+	print("	type	", addr.type, "\n");
+	print("	dev	", addr.dev, "\n");
+};
+
+sizeof_7_ = 28;
+aggr _7_
+{
+	'u' 0 oldtag;
+	Qid 4 qid;
+	'a' 12 rauth;
+};
+
+defn
+_7_(addr) {
+	complex _7_ addr;
+	print("	oldtag	", addr.oldtag, "\n");
+	print("Qid qid {\n");
+	Qid(addr.qid);
+	print("}\n");
+	print("	rauth	", addr.rauth, "\n");
+};
+
+sizeof_8_ = 144;
+aggr _8_
+{
+	'a' 0 uname;
+	'a' 28 aname;
+	'a' 56 ticket;
+	'a' 128 auth;
+};
+
+defn
+_8_(addr) {
+	complex _8_ addr;
+	print("	uname	", addr.uname, "\n");
+	print("	aname	", addr.aname, "\n");
+	print("	ticket	", addr.ticket, "\n");
+	print("	auth	", addr.auth, "\n");
+};
+
+sizeof_9_ = 148;
+aggr _9_
+{
+	'a' 0 ename;
+	'a' 64 authid;
+	'a' 92 authdom;
+	'a' 140 chal;
+};
+
+defn
+_9_(addr) {
+	complex _9_ addr;
+	print("	ename	", addr.ename, "\n");
+	print("	authid	", addr.authid, "\n");
+	print("	authdom	", addr.authdom, "\n");
+	print("	chal	", addr.chal, "\n");
+};
+
+sizeof_10_ = 36;
+aggr _10_
+{
+	'D' 0 perm;
+	'd' 4 newfid;
+	'a' 6 name;
+	'C' 34 mode;
+};
+
+defn
+_10_(addr) {
+	complex _10_ addr;
+	print("	perm	", addr.perm, "\n");
+	print("	newfid	", addr.newfid, "\n");
+	print("	name	", addr.name, "\n");
+	print("	mode	", addr.mode, "\n");
+};
+
+sizeof_11_ = 12;
+aggr _11_
+{
+	'D' 0 offset;
+	'D' 4 count;
+	'X' 8 data;
+};
+
+defn
+_11_(addr) {
+	complex _11_ addr;
+	print("	offset	", addr.offset, "\n");
+	print("	count	", addr.count, "\n");
+	print("	data	", addr.data\X, "\n");
+};
+
+sizeof_12_ = 116;
+aggr _12_
+{
+	'a' 0 stat;
+};
+
+defn
+_12_(addr) {
+	complex _12_ addr;
+	print("	stat	", addr.stat, "\n");
+};
+
+sizeof_13_ = 148;
+aggr _13_
+{
+	{
+	'u' 0 oldtag;
+	Qid 4 qid;
+	'a' 12 rauth;
+	};
+	{
+	'a' 0 uname;
+	'a' 28 aname;
+	'a' 56 ticket;
+	'a' 128 auth;
+	};
+	{
+	'a' 0 ename;
+	'a' 64 authid;
+	'a' 92 authdom;
+	'a' 140 chal;
+	};
+	{
+	'D' 0 perm;
+	'd' 4 newfid;
+	'a' 6 name;
+	'C' 34 mode;
+	};
+	{
+	'D' 0 offset;
+	'D' 4 count;
+	'X' 8 data;
+	};
+	{
+	'a' 0 stat;
+	};
+};
+
+defn
+_13_(addr) {
+	complex _13_ addr;
+	print("_7_ {\n");
+		_7_(addr+0);
+	print("}\n");
+	print("_8_ {\n");
+		_8_(addr+0);
+	print("}\n");
+	print("_9_ {\n");
+		_9_(addr+0);
+	print("}\n");
+	print("_10_ {\n");
+		_10_(addr+0);
+	print("}\n");
+	print("_11_ {\n");
+		_11_(addr+0);
+	print("}\n");
+	print("_12_ {\n");
+		_12_(addr+0);
+	print("}\n");
+};
+
+sizeofFcall = 156;
+aggr Fcall
+{
+	'C' 0 type;
+	'd' 2 fid;
+	'u' 4 tag;
+	{
+	{
+	'u' 8 oldtag;
+	Qid 12 qid;
+	'a' 20 rauth;
+	};
+	{
+	'a' 8 uname;
+	'a' 36 aname;
+	'a' 64 ticket;
+	'a' 136 auth;
+	};
+	{
+	'a' 8 ename;
+	'a' 72 authid;
+	'a' 100 authdom;
+	'a' 148 chal;
+	};
+	{
+	'D' 8 perm;
+	'd' 12 newfid;
+	'a' 14 name;
+	'C' 42 mode;
+	};
+	{
+	'D' 8 offset;
+	'D' 12 count;
+	'X' 16 data;
+	};
+	{
+	'a' 8 stat;
+	};
+	};
+};
+
+defn
+Fcall(addr) {
+	complex Fcall addr;
+	print("	type	", addr.type, "\n");
+	print("	fid	", addr.fid, "\n");
+	print("	tag	", addr.tag, "\n");
+	print("_13_ {\n");
+		_13_(addr+8);
+	print("}\n");
+};
+
+sizeofMuxbuf = 16400;
+aggr Muxbuf
+{
+	'D' 0 n;
+	'X' 4 putnext;
+	'X' 8 getnext;
+	'b' 12 fd;
+	'b' 13 eof;
+	'b' 14 roomwait;
+	'b' 15 datawait;
+	'a' 16 data;
+};
+
+defn
+Muxbuf(addr) {
+	complex Muxbuf addr;
+	print("	n	", addr.n, "\n");
+	print("	putnext	", addr.putnext\X, "\n");
+	print("	getnext	", addr.getnext\X, "\n");
+	print("	fd	", addr.fd, "\n");
+	print("	eof	", addr.eof, "\n");
+	print("	roomwait	", addr.roomwait, "\n");
+	print("	datawait	", addr.datawait, "\n");
+	print("	data	", addr.data, "\n");
+};
+
+sizeofFdinfo = 16;
+aggr Fdinfo
+{
+	'U' 0 flags;
+	'U' 4 oflags;
+	'X' 8 name;
+	'A' Muxbuf 12 buf;
+};
+
+defn
+Fdinfo(addr) {
+	complex Fdinfo addr;
+	print("	flags	", addr.flags, "\n");
+	print("	oflags	", addr.oflags, "\n");
+	print("	name	", addr.name\X, "\n");
+	print("	buf	", addr.buf\X, "\n");
+};
+
+sizeofWaitmsg = 112;
+aggr Waitmsg
+{
+	'a' 0 pid;
+	'a' 12 time;
+	'a' 48 msg;
+};
+
+defn
+Waitmsg(addr) {
+	complex Waitmsg addr;
+	print("	pid	", addr.pid, "\n");
+	print("	time	", addr.time, "\n");
+	print("	msg	", addr.msg, "\n");
+};
+
+sizeofMuxseg = 65640;
+aggr Muxseg
+{
+	_4_ 0 lock;
+	'D' 4 curfds;
+	'D' 8 selwait;
+	'D' 12 waittime;
+	fd_set 16 rwant;
+	fd_set 28 ewant;
+	'a' 40 bufs;
+};
+
+defn
+Muxseg(addr) {
+	complex Muxseg addr;
+	print("_4_ lock {\n");
+	_4_(addr.lock);
+	print("}\n");
+	print("	curfds	", addr.curfds, "\n");
+	print("	selwait	", addr.selwait, "\n");
+	print("	waittime	", addr.waittime, "\n");
+	print("fd_set rwant {\n");
+	fd_set(addr.rwant);
+	print("}\n");
+	print("fd_set ewant {\n");
+	fd_set(addr.ewant);
+	print("}\n");
+	print("	bufs	", addr.bufs, "\n");
+};
+
+complex Muxseg mux;
+complex Fdinfo _startbuf:f;
+complex Muxbuf _startbuf:b;
+complex Muxbuf _copyproc:b;
+complex Muxbuf _readbuf:b;
+complex fd_set select:rfds;
+complex fd_set select:wfds;
+complex fd_set select:efds;
+complex timeval select:timeout;
+complex Fdinfo select:f;
+complex Muxbuf select:b;
diff --git a/sys/src/ape/lib/ap/plan9/alarm.c b/sys/src/ape/lib/ap/plan9/alarm.c
new file mode 100755
index 000000000..f8a24aa65
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/alarm.c
@@ -0,0 +1,9 @@
+#include "lib.h"
+#include <unistd.h>
+#include "sys9.h"
+
+unsigned int
+alarm(unsigned seconds)
+{
+	return _ALARM(seconds*1000);
+}
diff --git a/sys/src/ape/lib/ap/plan9/brk.c b/sys/src/ape/lib/ap/plan9/brk.c
new file mode 100755
index 000000000..0b3240377
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/brk.c
@@ -0,0 +1,36 @@
+#include "lib.h"
+#include <errno.h>
+#include "sys9.h"
+
+char	end[];
+static	char	*bloc = { end };
+extern	int	_BRK_(void*);
+
+char *
+brk(char *p)
+{
+	unsigned long n;
+
+	n = (unsigned long)p;
+	n += 3;
+	n &= ~3;
+	if(_BRK_((void*)n) < 0){
+		errno = ENOMEM;
+		return (char *)-1;
+	}
+	bloc = (char *)n;
+	return 0;
+}
+
+void *
+sbrk(unsigned long n)
+{
+	n += 3;
+	n &= ~3;
+	if(_BRK_((void *)(bloc+n)) < 0){
+		errno = ENOMEM;
+		return (void *)-1;
+	}
+	bloc += n;
+	return (void *)(bloc-n);
+}
diff --git a/sys/src/ape/lib/ap/plan9/buf.prom b/sys/src/ape/lib/ap/plan9/buf.prom
new file mode 100755
index 000000000..e8751dadd
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/buf.prom
@@ -0,0 +1,360 @@
+#define NBUFS 2
+#define READMAX 2
+#define BUFSIZ 2*READMAX
+#define EOF 255
+#define TIMEOUT 254
+#define FILEMAXLEN 20
+
+byte	n[NBUFS];
+byte ntotal[NBUFS];
+byte putnext[NBUFS];
+byte getnext[NBUFS];
+bool eof[NBUFS];
+bool roomwait[NBUFS];
+bool datawait[NBUFS];
+byte rwant;
+
+/* use one big data array to simulate 2-d array */
+#define bufstart(slot) (slot*BUFSIZ)
+#define bufend(slot) ((slot+1)*BUFSIZ)
+/* bit data[BUFSIZ*NBUFS]; */
+
+bool selwait;
+/* bool hastimeout; */
+
+#define get 0
+#define release 1
+
+chan lock = [0] of { bit };
+chan lockkill = [0] of { bit };
+chan sel = [0] of { byte };
+chan selcall = [0] of { byte };
+chan selans = [0] of { byte, byte };
+chan selkill = [0] of { bit };
+chan readcall = [0] of { byte, byte };
+chan readans = [0] of { byte };
+chan readkill = [0] of { bit };
+chan croom[NBUFS] = [0] of { bit };
+chan cdata[NBUFS] = [0] of { bit };
+
+proctype Lockrendez()
+{
+	do
+	:: lock!get -> lock?release
+	:: lockkill?release -> break
+	od
+}
+
+proctype Copy(byte fd)
+{
+	byte num;
+	bit b;
+
+	do  :: 1 ->
+		/* make sure there's room */
+		lock?get;
+		if
+		:: (BUFSIZ-putnext[fd]) < READMAX ->
+			if
+			:: getnext[fd] == putnext[fd] ->
+				getnext[fd] = 0;
+				putnext[fd] = 0;
+				lock!release
+			:: getnext[fd] != putnext[fd] ->
+				roomwait[fd] = 1;
+				lock!release;
+				croom[fd]?b
+			fi
+		:: (BUFSIZ-putnext[fd]) >= READMAX ->
+			lock!release
+		fi;
+		/* simulate read into data buf at putnext */
+		if
+		:: ntotal[fd] > FILEMAXLEN ->
+			num = EOF
+		:: ntotal[fd] <= FILEMAXLEN ->
+			if
+			:: num = 1
+			:: num = READMAX
+			:: num = EOF
+			fi
+		fi;
+		/* here is where data transfer would happen */
+		lock?get;
+		if
+		:: num == EOF ->
+			eof[fd] = 1;
+/* printf("Copy %d got eof\n", fd);/**/
+			if
+			:: datawait[fd] ->
+				datawait[fd] = 0;
+				lock!release;
+				cdata[fd]!1
+			:: !datawait[fd] && (rwant & (1<<fd)) && selwait ->
+				selwait = 0;
+				lock!release;
+				sel!fd
+			:: !datawait[fd] && !((rwant & (1<<fd)) && selwait) ->
+				lock!release
+			fi;
+			break
+		:: num != EOF ->
+/* printf("Copy %d putting %d in; old putnext=%d, old n=%d\n", fd, num, putnext[fd], n[fd]); /* */
+			putnext[fd] = putnext[fd] + num;
+			n[fd] = n[fd] + num;
+			ntotal[fd] = ntotal[fd] + num;
+			assert(n[fd] > 0);
+			if
+			:: datawait[fd] ->
+				datawait[fd] = 0;
+				lock!release;
+				cdata[fd]!1
+			:: !datawait[fd] && (rwant & (1<<fd)) && selwait ->
+				selwait = 0;
+				lock!release;
+				sel!fd
+			:: !datawait[fd] && !((rwant & (1<<fd)) && selwait) ->
+				lock!release
+			fi
+		fi;
+	od
+}
+
+proctype Read()
+{
+	byte ngot;
+	byte fd;
+	byte nwant;
+	bit b;
+
+    do
+    :: readcall?fd,nwant ->
+	if
+	:: eof[fd] && n[fd] == 0 ->
+		readans!EOF
+	:: !(eof[fd] && n[fd] == 0) ->
+		lock?get;
+		ngot = putnext[fd] - getnext[fd];
+/* printf("Reading %d, want %d: ngot = %d - %d, n = %d\n", fd, nwant, putnext[fd], getnext[fd], n[fd]); /* */
+		if
+		:: ngot == 0 ->
+			if
+			:: eof[fd] ->
+				skip
+			:: !eof[fd] ->
+				/* sleep until there's data */
+				datawait[fd] = 1;
+/* printf("Read sleeping\n"); /* */
+				lock!release;
+				cdata[fd]?b;
+				lock?get;
+				ngot = putnext[fd] - getnext[fd];
+/* printf("Read awoke, ngot = %d\n", ngot); /**/
+			fi
+		:: ngot != 0 -> skip
+		fi;
+		if
+		:: ngot > nwant -> ngot = nwant
+		:: ngot <= nwant -> skip
+		fi;
+		/* here would take ngot elements from data, from getnext[fd] ... */
+		getnext[fd] = getnext[fd] + ngot;
+		assert(n[fd] >= ngot);
+		n[fd] = n[fd] - ngot;
+		if
+		:: ngot == 0 ->
+			assert(eof[fd]);
+			ngot = EOF
+		:: ngot != 0 -> skip
+		fi;
+		if
+		:: getnext[fd] == putnext[fd] && roomwait[fd] ->
+			getnext[fd] = 0;
+			putnext[fd] = 0;
+			roomwait[fd] = 0;
+			lock!release;
+			croom[fd]!0
+		:: getnext[fd] != putnext[fd] || !roomwait[fd] ->
+			lock!release
+		fi;
+		readans!ngot
+	fi
+    :: readkill?b -> break
+    od
+}
+
+proctype Select()
+{
+	byte num;
+	byte i;
+	byte fd;
+	byte r;
+	bit b;
+
+    do
+    :: selcall?r ->
+/* printf("Select called, r=%d\n", r); /**/
+	i = 0;
+	do
+	:: i < NBUFS ->
+		if
+		:: r & (1<<i) ->
+			if
+			:: eof[i] && n[i] == 0 ->
+/* printf("Select got eof on %d\n", i);/**/
+				num = EOF;
+				r = i;
+				goto donesel
+			:: !eof[i] || n[i] != 0 -> skip
+			fi
+		:: !(r & (1<<i)) -> skip
+		fi;
+		i = i+1
+	:: i >= NBUFS -> break
+	od;
+	num = 0;
+	lock?get;
+	rwant = 0;
+	i = 0;
+	do
+	:: i < NBUFS ->
+		if
+		:: r & (1<<i) ->
+			if
+			:: n[i] > 0 || eof[i] ->
+/* printf("Select found %d has n==%d\n", i, n[i]); /**/
+				num = num+1
+			:: n[i] == 0 && !eof[i] ->
+/* printf("Select asks to wait for %d\n", i); /**/
+				r = r &(~(1<<i));
+				rwant = rwant | (1<<i)
+			fi
+		:: !(r & (1<<i)) -> skip
+		fi;
+		i = i+1
+	:: i >= NBUFS -> break
+	od;
+	if
+	:: num > 0 || rwant == 0 ->
+		rwant = 0;
+		lock!release;
+	:: num == 0 && rwant != 0 ->
+		selwait = 1;
+		lock!release;
+/* printf("Select sleeps\n"); /**/
+		sel?fd;
+/* printf("Select wakes up, fd=%d\n", fd); /**/
+		if
+		:: fd != TIMEOUT ->
+			if
+			:: (rwant & (1<<fd)) && (n[fd] > 0) ->
+				r = r | (1<<fd);
+				num = 1
+			:: !(rwant & (1<<fd)) || (n[fd] == 0) ->
+				num = 0
+			fi
+		:: fd == TIMEOUT -> skip
+		fi;
+		rwant = 0
+	fi;
+  donesel:
+	selans!num,r
+    :: selkill?b -> break
+    od
+}
+
+/* This routine is written knowing NBUFS == 2 in several places */
+proctype User()
+{
+	byte ndone;
+	byte i;
+	byte rw;
+	byte num;
+	byte nwant;
+	byte fd;
+	bool goteof[NBUFS];
+
+	ndone = 0;
+	do
+	:: ndone == NBUFS -> break
+	:: ndone < NBUFS ->
+		if
+		:: 1->
+			/* maybe use Read */
+/* printf("User trying to read.  Current goteofs: %d %d\n", goteof[0], goteof[1]); /**/
+			/* randomly pick fd 0 or 1 from non-eof ones */
+			if
+			:: !goteof[0] -> fd = 0
+			:: !goteof[1] -> fd = 1
+			fi;
+			if
+			:: nwant = 1
+			:: nwant = READMAX
+			fi;
+			readcall!fd,nwant;
+			readans?num;
+			if
+			:: num == EOF ->
+				goteof[fd] = 1;
+				ndone = ndone + 1
+			:: num != EOF -> assert(num != 0)
+			fi
+		:: 1->
+/* printf("User trying to select.  Current goteofs: %d %d\n", goteof[0], goteof[1]); /**/
+			/* maybe use Select, then Read */
+			/* randomly set the "i want" bit for non-eof fds */
+			if
+			:: !goteof[0] && !goteof[1] -> rw = (1<<0) | (1<<1)
+			:: !goteof[0] -> rw = (1<<0)
+			:: !goteof[1] -> rw = (1<<1)
+			fi;
+			selcall!rw;
+			selans?i,rw;
+			if
+			:: i == EOF ->
+				goteof[rw] = 1;
+				ndone = ndone + 1
+			:: i != EOF ->
+				/* this next statement knows NBUFS == 2 ! */
+				if
+				:: rw & (1<<0) -> fd = 0
+				:: rw & (1<<1) -> fd = 1
+				:: rw == 0 -> fd = EOF
+				fi;
+				if
+				:: nwant = 1
+				:: nwant = READMAX
+				fi;
+				if
+				:: fd != EOF ->
+					readcall!fd,nwant;
+					readans?num;
+					assert(num != 0)
+				:: fd == EOF -> skip
+				fi
+			fi
+		fi
+	od;
+	lockkill!release;
+	selkill!release;
+	readkill!release
+}
+
+init
+{
+	byte i;
+
+	atomic {
+		run Lockrendez();
+		i = 0;
+		do
+		:: i < NBUFS ->
+			run Copy(i);
+			i = i+1
+		:: i >= NBUFS -> break
+		od;
+		run Select();
+		run Read();
+		run User()
+	}
+}
diff --git a/sys/src/ape/lib/ap/plan9/cfgetospeed.c b/sys/src/ape/lib/ap/plan9/cfgetospeed.c
new file mode 100755
index 000000000..cc89f4a86
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/cfgetospeed.c
@@ -0,0 +1,26 @@
+#include <termios.h>
+
+speed_t
+cfgetospeed(const struct termios *p)
+{
+	return B0;
+}
+
+int
+cfsetospeed(struct termios *p, speed_t s)
+{
+	return 0;
+}
+
+speed_t
+cfgetispeed(const struct termios *p)
+{
+	return B0;
+}
+
+int
+cfsetispeed(struct termios *p, speed_t s)
+{
+	return 0;
+}
+
diff --git a/sys/src/ape/lib/ap/plan9/chdir.c b/sys/src/ape/lib/ap/plan9/chdir.c
new file mode 100755
index 000000000..245f116d0
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/chdir.c
@@ -0,0 +1,14 @@
+#include "lib.h"
+#include <unistd.h>
+#include "sys9.h"
+
+int
+chdir(const char *f)
+{
+	int n;
+
+	n = _CHDIR(f);
+	if(n < 0)
+		_syserrno();
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/chmod.c b/sys/src/ape/lib/ap/plan9/chmod.c
new file mode 100755
index 000000000..8b6daad22
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/chmod.c
@@ -0,0 +1,33 @@
+#include "lib.h"
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+chmod(const char *path, mode_t mode)
+{
+	Dir d;
+
+	_nulldir(&d);
+	d.mode = mode & 0777;
+	if(_dirwstat(path, &d) < 0){
+		_syserrno();	
+		return -1;
+	}
+	return 0;
+}
+
+int
+fchmod(int fd, mode_t mode)
+{
+	Dir d;
+
+	_nulldir(&d);
+	d.mode = mode & 0777;
+	if(_dirfwstat(fd, &d) < 0){
+		_syserrno();	
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/chown.c b/sys/src/ape/lib/ap/plan9/chown.c
new file mode 100755
index 000000000..22b651d14
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/chown.c
@@ -0,0 +1,39 @@
+#include "lib.h"
+#include "sys9.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "dir.h"
+
+int
+chown(const char *path, uid_t owner, gid_t group)
+{
+	int num;
+	Dir d;
+
+	_nulldir(&d);
+
+	/* find owner, group */
+	d.uid = nil;
+	num = owner;
+	if(!_getpw(&num, &d.uid, 0)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	d.gid = nil;
+	num = group;
+	if(!_getpw(&num, &d.gid, 0)) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(_dirwstat(path, &d) < 0){
+		_syserrno();
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/close.c b/sys/src/ape/lib/ap/plan9/close.c
new file mode 100755
index 000000000..258788a39
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/close.c
@@ -0,0 +1,34 @@
+#include "lib.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include "sys9.h"
+
+int
+close(int d)
+{
+	int n;
+	Fdinfo *f;
+
+	n = -1;
+	f = &_fdinfo[d];
+	if(d<0 || d>=OPEN_MAX || !(f->flags&FD_ISOPEN))
+		errno = EBADF;
+	else{
+		if(f->flags&(FD_BUFFERED|FD_BUFFEREDX)) {
+			if(f->flags&FD_BUFFERED)
+				_closebuf(d);
+			f->flags &= ~FD_BUFFERED;
+		}
+		n = _CLOSE(d);
+		if(n < 0)
+			_syserrno();
+		_fdinfo[d].flags = 0;
+		_fdinfo[d].oflags = 0;
+		if(_fdinfo[d].name){
+			free(_fdinfo[d].name);
+			_fdinfo[d].name = 0;
+		}
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/convD2M.c b/sys/src/ape/lib/ap/plan9/convD2M.c
new file mode 100755
index 000000000..fc1ade5c5
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/convD2M.c
@@ -0,0 +1,93 @@
+#include "lib.h"
+#include <string.h>
+#include "sys9.h"
+#include "dir.h"
+
+uint
+_convD2M(Dir *d, uchar *buf, uint nbuf)
+{
+	uchar *p, *ebuf;
+	char *sv[4];
+	int i, ns, nsv[4], ss;
+
+	if(nbuf < BIT16SZ)
+		return 0;
+
+	p = buf;
+	ebuf = buf + nbuf;
+
+	sv[0] = d->name;
+	sv[1] = d->uid;
+	sv[2] = d->gid;
+	sv[3] = d->muid;
+
+	ns = 0;
+	for(i = 0; i < 4; i++){
+		nsv[i] = strlen(sv[i]);
+		ns += nsv[i];
+	}
+
+	ss = STATFIXLEN + ns;
+
+	/* set size befor erroring, so user can know how much is needed */
+	/* note that length excludes count field itself */
+	PBIT16(p, ss-BIT16SZ);
+	p += BIT16SZ;
+
+	if(ss > nbuf)
+		return BIT16SZ;
+
+	PBIT16(p, d->type);
+	p += BIT16SZ;
+	PBIT32(p, d->dev);
+	p += BIT32SZ;
+	PBIT8(p, d->qid.type);
+	p += BIT8SZ;
+	PBIT32(p, d->qid.vers);
+	p += BIT32SZ;
+	PBIT64(p, d->qid.path);
+	p += BIT64SZ;
+	PBIT32(p, d->mode);
+	p += BIT32SZ;
+	PBIT32(p, d->atime);
+	p += BIT32SZ;
+	PBIT32(p, d->mtime);
+	p += BIT32SZ;
+	PBIT64(p, d->length);
+	p += BIT64SZ;
+
+	for(i = 0; i < 4; i++){
+		ns = nsv[i];
+		if(p + ns + BIT16SZ > ebuf)
+			return 0;
+		PBIT16(p, ns);
+		p += BIT16SZ;
+		memmove(p, sv[i], ns);
+		p += ns;
+	}
+
+	if(ss != p - buf)
+		return 0;
+
+	return p - buf;
+}
+
+uint
+_sizeD2M(Dir *d)
+{
+	char *sv[4];
+	int i, ns;
+
+	sv[0] = d->name;
+	sv[1] = d->uid;
+	sv[2] = d->gid;
+	sv[3] = d->muid;
+
+	ns = 0;
+	for(i = 0; i < 4; i++)
+		if(sv[i])
+			ns += strlen(sv[i]);
+
+	return STATFIXLEN + ns;
+}
+
diff --git a/sys/src/ape/lib/ap/plan9/convM2D.c b/sys/src/ape/lib/ap/plan9/convM2D.c
new file mode 100755
index 000000000..222e88927
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/convM2D.c
@@ -0,0 +1,74 @@
+#include "lib.h"
+#include <string.h>
+#include "sys9.h"
+#include "dir.h"
+#define nil ((void*)0)
+
+static char nullstring[] = "";
+
+uint
+_convM2D(uchar *buf, uint nbuf, Dir *d, char *strs)
+{
+	uchar *p, *ebuf;
+	char *sv[4];
+	int i, ns, nsv[4];
+
+	p = buf;
+	ebuf = buf + nbuf;
+
+	p += BIT16SZ;	/* ignore size */
+	d->type = GBIT16(p);
+	p += BIT16SZ;
+	d->dev = GBIT32(p);
+	p += BIT32SZ;
+	d->qid.type = GBIT8(p);
+	p += BIT8SZ;
+	d->qid.vers = GBIT32(p);
+	p += BIT32SZ;
+	d->qid.path = GBIT64(p);
+	p += BIT64SZ;
+	d->mode = GBIT32(p);
+	p += BIT32SZ;
+	d->atime = GBIT32(p);
+	p += BIT32SZ;
+	d->mtime = GBIT32(p);
+	p += BIT32SZ;
+	d->length = GBIT64(p);
+	p += BIT64SZ;
+
+	d->name = nil;
+	d->uid = nil;
+	d->gid = nil;
+	d->muid = nil;
+
+	for(i = 0; i < 4; i++){
+		if(p + BIT16SZ > ebuf)
+			return 0;
+		ns = GBIT16(p);
+		p += BIT16SZ;
+		if(p + ns > ebuf)
+			return 0;
+		if(strs){
+			nsv[i] = ns;
+			sv[i] = strs;
+			memmove(strs, p, ns);
+			strs += ns;
+			*strs++ = '\0';
+		}
+		p += ns;
+	}
+
+	if(strs){
+		d->name = sv[0];
+		d->uid = sv[1];
+		d->gid = sv[2];
+		d->muid = sv[3];
+	}else{
+		d->name = nullstring;
+		d->uid = nullstring;
+		d->gid = nullstring;
+		d->muid = nullstring;
+	}
+	
+	return p - buf;
+}
diff --git a/sys/src/ape/lib/ap/plan9/creat.c b/sys/src/ape/lib/ap/plan9/creat.c
new file mode 100755
index 000000000..a0f917a62
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/creat.c
@@ -0,0 +1,13 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int
+creat(const char *name, mode_t mode)
+{
+	int n;
+
+	n = open(name, O_WRONLY | O_CREAT | O_TRUNC, mode);
+	/* no need to _syserrno; open did it already */
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/ctermid.c b/sys/src/ape/lib/ap/plan9/ctermid.c
new file mode 100755
index 000000000..a8689a71f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/ctermid.c
@@ -0,0 +1,20 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+
+char *
+ctermid(char *s)
+{
+	static char buf[L_ctermid];
+
+	if(s == 0)
+		s = buf;
+	strncpy(s, "/dev/cons", sizeof buf);
+	return(s);
+}
+
+char *
+ctermid_r(char *s)
+{
+	return s ? ctermid(s) : NULL;
+}
diff --git a/sys/src/ape/lib/ap/plan9/ctime.c b/sys/src/ape/lib/ap/plan9/ctime.c
new file mode 100755
index 000000000..34a0b12a5
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/ctime.c
@@ -0,0 +1,321 @@
+/*
+ * This routine converts time as follows.
+ * The epoch is 0000 Jan 1 1970 GMT.
+ * The argument time is in seconds since then.
+ * The localtime(t) entry returns a pointer to an array
+ * containing
+ *
+ *	seconds (0-59)
+ *	minutes (0-59)
+ *	hours (0-23)
+ *	day of month (1-31)
+ *	month (0-11)
+ *	year-1970
+ *	weekday (0-6, Sun is 0)
+ *	day of the year
+ *	daylight savings flag
+ *
+ * The routine gets the daylight savings time from the environment.
+ *
+ * asctime(tvec))
+ * where tvec is produced by localtime
+ * returns a ptr to a character string
+ * that has the ascii time in the form
+ *
+ *	                            \\
+ *	Thu Jan 01 00:00:00 1970n0
+ *	01234567890123456789012345
+ *	0	  1	    2
+ *
+ * ctime(t) just calls localtime, then asctime.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+
+static	char	dmsize[12] =
+{
+	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+
+/*
+ * The following table is used for 1974 and 1975 and
+ * gives the day number of the first day after the Sunday of the
+ * change.
+ */
+
+static	int	dysize(int);
+static	void	ct_numb(char*, int);
+static	void	readtimezone(void);
+static	int	rd_name(char**, char*);
+static	int	rd_long(char**, long*);
+
+#define	TZSIZE	150
+
+static
+struct
+{
+	char	stname[4];
+	char	dlname[4];
+	long	stdiff;
+	long	dldiff;
+	long	dlpairs[TZSIZE];
+} timezone;
+
+char*
+ctime(const time_t *t)
+{
+	return asctime(localtime(t));
+}
+
+struct tm*
+gmtime_r(const time_t *timp, struct tm *result)
+{
+	int d0, d1;
+	long hms, day;
+	time_t tim;
+
+	tim = *timp;
+	/*
+	 * break initial number into days
+	 */
+	hms = tim % 86400L;
+	day = tim / 86400L;
+	if(hms < 0) {
+		hms += 86400L;
+		day -= 1;
+	}
+
+	/*
+	 * generate hours:minutes:seconds
+	 */
+	result->tm_sec = hms % 60;
+	d1 = hms / 60;
+	result->tm_min = d1 % 60;
+	d1 /= 60;
+	result->tm_hour = d1;
+
+	/*
+	 * day is the day number.
+	 * generate day of the week.
+	 * The addend is 4 mod 7 (1/1/1970 was Thursday)
+	 */
+
+	result->tm_wday = (day + 7340036L) % 7;
+
+	/*
+	 * year number
+	 */
+	if(day >= 0)
+		for(d1 = 70; day >= dysize(d1); d1++)
+			day -= dysize(d1);
+	else
+		for (d1 = 70; day < 0; d1--)
+			day += dysize(d1-1);
+	result->tm_year = d1;
+	result->tm_yday = d0 = day;
+
+	/*
+	 * generate month
+	 */
+
+	if(dysize(d1) == 366)
+		dmsize[1] = 29;
+	for(d1 = 0; d0 >= dmsize[d1]; d1++)
+		d0 -= dmsize[d1];
+	dmsize[1] = 28;
+	result->tm_mday = d0 + 1;
+	result->tm_mon = d1;
+	result->tm_isdst = 0;
+	return result;
+}
+
+struct tm*
+gmtime(const time_t *timp)
+{
+	static struct tm xtime;
+
+	return gmtime_r(timp, &xtime);
+}
+
+struct tm*
+localtime_r(const time_t *timp, struct tm *result)
+{
+	struct tm *ct;
+	time_t t, tim;
+	long *p;
+	int i, dlflag;
+
+	tim = *timp;
+	if(timezone.stname[0] == 0)
+		readtimezone();
+	t = tim + timezone.stdiff;
+	dlflag = 0;
+	for(p = timezone.dlpairs; *p; p += 2)
+		if(t >= p[0])
+		if(t < p[1]) {
+			t = tim + timezone.dldiff;
+			dlflag++;
+			break;
+		}
+	ct = gmtime_r(&t, result);
+	ct->tm_isdst = dlflag;
+	return ct;
+}
+
+struct tm*
+localtime(const time_t *timp)
+{
+	static struct tm xtime;
+
+	return localtime_r(timp, &xtime);
+}
+
+char*
+asctime_r(const struct tm *t, char *buf)
+{
+	char *ncp;
+
+	strcpy(buf, "Thu Jan 01 00:00:00 1970\n");
+	ncp = &"SunMonTueWedThuFriSat"[t->tm_wday*3];
+	buf[0] = *ncp++;
+	buf[1] = *ncp++;
+	buf[2] = *ncp;
+	ncp = &"JanFebMarAprMayJunJulAugSepOctNovDec"[t->tm_mon*3];
+	buf[4] = *ncp++;
+	buf[5] = *ncp++;
+	buf[6] = *ncp;
+	ct_numb(buf+8, t->tm_mday);
+	ct_numb(buf+11, t->tm_hour+100);
+	ct_numb(buf+14, t->tm_min+100);
+	ct_numb(buf+17, t->tm_sec+100);
+	if(t->tm_year >= 100) {
+		buf[20] = '2';
+		buf[21] = '0';
+	}
+	ct_numb(buf+22, t->tm_year+100);
+	return buf;
+}
+
+char*
+asctime(const struct tm *t)
+{
+	static char cbuf[30];
+
+	return asctime_r(t, cbuf);
+}
+
+static
+dysize(int y)
+{
+	if((y%4) == 0)
+		return 366;
+	return 365;
+}
+
+static
+void
+ct_numb(char *cp, int n)
+{
+	cp[0] = ' ';
+	if(n >= 10)
+		cp[0] = (n/10)%10 + '0';
+	cp[1] = n%10 + '0';
+}
+
+static
+void
+readtimezone(void)
+{
+	char buf[TZSIZE*11+30], *p;
+	int i;
+
+	memset(buf, 0, sizeof(buf));
+	i = open("/env/timezone", 0);
+	if(i < 0)
+		goto error;
+	if(read(i, buf, sizeof(buf)) >= sizeof(buf))
+		goto error;
+	close(i);
+	p = buf;
+	if(rd_name(&p, timezone.stname))
+		goto error;
+	if(rd_long(&p, &timezone.stdiff))
+		goto error;
+	if(rd_name(&p, timezone.dlname))
+		goto error;
+	if(rd_long(&p, &timezone.dldiff))
+		goto error;
+	for(i=0; i<TZSIZE; i++) {
+		if(rd_long(&p, &timezone.dlpairs[i]))
+			goto error;
+		if(timezone.dlpairs[i] == 0)
+			return;
+	}
+
+error:
+	timezone.stdiff = 0;
+	strcpy(timezone.stname, "GMT");
+	timezone.dlpairs[0] = 0;
+}
+
+static
+rd_name(char **f, char *p)
+{
+	int c, i;
+
+	for(;;) {
+		c = *(*f)++;
+		if(c != ' ' && c != '\n')
+			break;
+	}
+	for(i=0; i<3; i++) {
+		if(c == ' ' || c == '\n')
+			return 1;
+		*p++ = c;
+		c = *(*f)++;
+	}
+	if(c != ' ' && c != '\n')
+		return 1;
+	*p = 0;
+	return 0;
+}
+
+static
+rd_long(char **f, long *p)
+{
+	int c, s;
+	long l;
+
+	s = 0;
+	for(;;) {
+		c = *(*f)++;
+		if(c == '-') {
+			s++;
+			continue;
+		}
+		if(c != ' ' && c != '\n')
+			break;
+	}
+	if(c == 0) {
+		*p = 0;
+		return 0;
+	}
+	l = 0;
+	for(;;) {
+		if(c == ' ' || c == '\n')
+			break;
+		if(c < '0' || c > '9')
+			return 1;
+		l = l*10 + c-'0';
+		c = *(*f)++;
+	}
+	if(s)
+		l = -l;
+	*p = l;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/cuserid.c b/sys/src/ape/lib/ap/plan9/cuserid.c
new file mode 100755
index 000000000..bf78bb3d2
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/cuserid.c
@@ -0,0 +1,21 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+
+/*
+ * BUG: supposed to be for effective uid,
+ * but plan9 doesn't have that concept
+ */
+char *
+cuserid(char *s)
+{
+	char *logname;
+	static char buf[L_cuserid];
+
+	if((logname = getlogin()) == NULL)
+		return(NULL);
+	if(s == 0)
+		s = buf;
+	strncpy(s, logname, sizeof buf);
+	return(s);
+}
diff --git a/sys/src/ape/lib/ap/plan9/dir.h b/sys/src/ape/lib/ap/plan9/dir.h
new file mode 100755
index 000000000..2af4f3e96
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/dir.h
@@ -0,0 +1,80 @@
+typedef	long	long	vlong;
+typedef	unsigned long long uvlong;
+typedef 	unsigned char uchar;
+typedef	unsigned short ushort;
+typedef 	unsigned int uint;
+typedef	unsigned long ulong;
+
+#define	GBIT8(p)	((p)[0])
+#define	GBIT16(p)	((p)[0]|((p)[1]<<8))
+#define	GBIT32(p)	((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24))
+#define	GBIT64(p)	((vlong)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
+				((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
+
+#define	PBIT8(p,v)	(p)[0]=(v)
+#define	PBIT16(p,v)	(p)[0]=(v);(p)[1]=(v)>>8
+#define	PBIT32(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24
+#define	PBIT64(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\
+			(p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56
+
+#define	BIT8SZ		1
+#define	BIT16SZ		2
+#define	BIT32SZ		4
+#define	BIT64SZ		8
+#define	QIDSZ	(BIT8SZ+BIT32SZ+BIT64SZ)
+
+/* STATFIXLEN includes leading 16-bit count */
+/* The count, however, excludes itself; total size is BIT16SZ+count */
+#define STATFIXLEN	(BIT16SZ+QIDSZ+5*BIT16SZ+4*BIT32SZ+1*BIT64SZ)	/* amount of fixed length data in a stat buffer */
+
+typedef union
+{
+	char	clength[8];
+	vlong	vlength;
+	struct
+	{
+		long	hlength;
+		long	length;
+	};
+} Length;
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length: see <u.h> */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+void	_dirtostat(struct stat *, Dir*, Fdinfo*);
+uint	_convM2D(uchar*, uint, Dir*, char*);
+uint	_convD2M(Dir*, uchar*, uint);
+Dir	*_dirstat(char*);
+int	_dirwstat(char*, Dir*);
+Dir	*_dirfstat(int);
+int	_dirfwstat(int, Dir*);
+long	_dirread(int, Dir**);
+long _dirreadall(int, Dir**);
+void _nulldir(Dir*);
+uint _sizeD2M(Dir*);
+
+#ifndef nil
+#define nil ((void*)0)
+#endif
diff --git a/sys/src/ape/lib/ap/plan9/dirread.c b/sys/src/ape/lib/ap/plan9/dirread.c
new file mode 100755
index 000000000..e03d32d77
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/dirread.c
@@ -0,0 +1,119 @@
+#include "lib.h"
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+static int
+statcheck(uchar *buf, uint nbuf)
+{
+	uchar *ebuf;
+	int i;
+
+	ebuf = buf + nbuf;
+
+	buf += STATFIXLEN - 4 * BIT16SZ;
+
+	for(i = 0; i < 4; i++){
+		if(buf + BIT16SZ > ebuf)
+			return -1;
+		buf += BIT16SZ + GBIT16(buf);
+	}
+
+	if(buf != ebuf)
+		return -1;
+
+	return 0;
+}
+
+static
+long
+dirpackage(uchar *buf, long ts, Dir **d)
+{
+	char *s;
+	long ss, i, n, nn, m;
+
+	if(ts == 0){
+		*d = nil;
+		return 0;
+	}
+
+	/*
+	 * first find number of all stats, check they look like stats, & size all associated strings
+	 */
+	ss = 0;
+	n = 0;
+	for(i = 0; i < ts; i += m){
+		m = BIT16SZ + GBIT16(&buf[i]);
+		if(statcheck(&buf[i], m) < 0)
+			break;
+		ss += m;
+		n++;
+	}
+
+	if(i != ts)
+		return -1;
+
+	*d = malloc(n * sizeof(Dir) + ss);
+	if(*d == nil)
+		return -1;
+
+	/*
+	 * then convert all buffers
+	 */
+	s = (char*)*d + n * sizeof(Dir);
+	nn = 0;
+	for(i = 0; i < ts; i += m){
+		m = BIT16SZ + GBIT16((uchar*)&buf[i]);
+		if(nn >= n || _convM2D(&buf[i], m, *d + nn, s) != m){
+			free(*d);
+			return -1;
+		}
+		nn++;
+		s += m;
+	}
+
+	return nn;
+}
+
+long
+_dirread(int fd, Dir **d)
+{
+	uchar *buf;
+	long ts;
+
+	buf = malloc(DIRMAX);
+	if(buf == nil)
+		return -1;
+	ts = _READ(fd, buf, DIRMAX);
+	if(ts >= 0)
+		ts = dirpackage(buf, ts, d);
+	free(buf);
+	return ts;
+}
+
+long
+_dirreadall(int fd, Dir **d)
+{
+	uchar *buf, *nbuf;
+	long n, ts;
+
+	buf = nil;
+	ts = 0;
+	for(;;){
+		nbuf = realloc(buf, ts+DIRMAX);
+		if(nbuf == nil){
+			free(buf);
+			return -1;
+		}
+		buf = nbuf;
+		n = _READ(fd, buf+ts, DIRMAX);
+		if(n <= 0)
+			break;
+		ts += n;
+	}
+	if(ts >= 0)
+		ts = dirpackage(buf, ts, d);
+	free(buf);
+	return ts;
+}
diff --git a/sys/src/ape/lib/ap/plan9/dirstat.c b/sys/src/ape/lib/ap/plan9/dirstat.c
new file mode 100755
index 000000000..f054b4f6e
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/dirstat.c
@@ -0,0 +1,107 @@
+#include "lib.h"
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+enum
+{
+	DIRSIZE	= STATFIXLEN + 16 * 4		/* enough for encoded stat buf + some reasonable strings */
+};
+
+Dir*
+_dirstat(char *name)
+{
+	Dir *d;
+	uchar *buf;
+	int n, nd, i;
+
+	nd = DIRSIZE;
+	for(i=0; i<2; i++){	/* should work by the second try */
+		d = malloc(sizeof(Dir) + BIT16SZ +nd);
+		if(d == nil)
+			return nil;
+		buf = (uchar*)&d[1];
+		n = _STAT(name, buf, BIT16SZ+nd);
+		if(n < BIT16SZ){
+			free(d);
+			return nil;
+		}
+		nd = GBIT16((uchar*)buf);	/* size needed to store whole stat buffer */
+		if(nd <= n){
+			_convM2D(buf, n, d, (char*)&d[1]);
+			return d;
+		}
+		/* else sizeof(Dir)+BIT16SZ+nd is plenty */
+		free(d);
+	}
+	return nil;
+}
+
+int
+_dirwstat(char *name, Dir *d)
+{
+	uchar *buf;
+	int r;
+
+	r = _sizeD2M(d);
+	buf = malloc(r);
+	if(buf == nil)
+		return -1;
+	_convD2M(d, buf, r);
+	r = _WSTAT(name, buf, r);
+	free(buf);
+	return r;
+}
+
+Dir*
+_dirfstat(int fd)
+{
+	Dir *d;
+	uchar *buf;
+	int n, nd, i;
+
+	nd = DIRSIZE;
+	for(i=0; i<2; i++){	/* should work by the second try */
+		d = malloc(sizeof(Dir) + nd);
+		if(d == nil)
+			return nil;
+		buf = (uchar*)&d[1];
+		n = _FSTAT(fd, buf, nd);
+		if(n < BIT16SZ){
+			free(d);
+			return nil;
+		}
+		nd = GBIT16(buf);	/* size needed to store whole stat buffer */
+		if(nd <= n){
+			_convM2D(buf, n, d, (char*)&d[1]);
+			return d;
+		}
+		/* else sizeof(Dir)+nd is plenty */
+		free(d);
+	}
+	return nil;
+}
+
+int
+_dirfwstat(int fd, Dir *d)
+{
+	uchar *buf;
+	int r;
+
+	r = _sizeD2M(d);
+	buf = malloc(r);
+	if(buf == nil)
+		return -1;
+	_convD2M(d, buf, r);
+	r = _FWSTAT(fd, buf, r);
+	free(buf);
+	return r;
+}
+
+void
+_nulldir(Dir *d)
+{
+	memset(d, ~0, sizeof(Dir));
+	d->name = d->uid = d->gid = d->muid = "";
+}
diff --git a/sys/src/ape/lib/ap/plan9/dirtostat.c b/sys/src/ape/lib/ap/plan9/dirtostat.c
new file mode 100755
index 000000000..6abc6dfa7
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/dirtostat.c
@@ -0,0 +1,52 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <errno.h>
+#include "sys9.h"
+#include "dir.h"
+
+/* fi is non-null if there is an fd associated with s */
+void
+_dirtostat(struct stat *s, Dir *d, Fdinfo *fi)
+{
+	int num;
+	char *nam;
+
+	s->st_dev = (d->type<<8)|(d->dev&0xFF);
+	s->st_ino = d->qid.path;
+	s->st_mode = d->mode&0777;
+	if(fi && (fi->flags&FD_ISTTY))
+		s->st_mode |= S_IFCHR;
+	else if(d->mode & 0x80000000)
+		s->st_mode |= S_IFDIR;
+	else if(d->type == '|' || d->type == 's')
+		s->st_mode |= S_IFIFO;
+	else if(d->type != 'M')
+		s->st_mode |= S_IFCHR;
+	else
+		s->st_mode |= S_IFREG;
+	s->st_nlink = 1;
+	s->st_uid = 1;
+	s->st_gid = 1;
+	if(fi && (fi->flags&FD_BUFFERED))
+		s->st_size = fi->buf->n;
+	else
+		s->st_size = d->length;
+	s->st_atime = d->atime;
+	s->st_mtime = d->mtime;
+	s->st_ctime = d->mtime;
+	if(fi && fi->uid != -2){
+		s->st_uid = fi->uid;
+		s->st_gid = fi->gid;
+	} else {
+		nam = d->uid;
+		if(_getpw(&num, &nam, 0))
+			s->st_uid = num;
+		nam = d->gid;
+		if(_getpw(&num, &nam, 0))
+			s->st_gid = num;
+		if(fi){
+			fi->uid = s->st_uid;
+			fi->gid = s->st_gid;
+		}
+	}
+}
diff --git a/sys/src/ape/lib/ap/plan9/dup.c b/sys/src/ape/lib/ap/plan9/dup.c
new file mode 100755
index 000000000..37883be52
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/dup.c
@@ -0,0 +1,24 @@
+#include "lib.h"
+#include <unistd.h>
+#include <errno.h>
+
+int
+dup(int oldd)
+{
+	return fcntl(oldd, F_DUPFD, 0);
+}
+
+int
+dup2(int oldd, int newd)
+{
+	int n;
+
+	if(newd < 0 || newd >= OPEN_MAX){
+		errno = EBADF;
+		return -1;
+	}
+	if(oldd == newd && _fdinfo[newd].flags&FD_ISOPEN)
+		return newd;
+	close(newd);
+	return fcntl(oldd, F_DUPFD, newd);
+}
diff --git a/sys/src/ape/lib/ap/plan9/execl.c b/sys/src/ape/lib/ap/plan9/execl.c
new file mode 100755
index 000000000..79ffa44c3
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execl.c
@@ -0,0 +1,9 @@
+#include <unistd.h>
+
+extern char **environ;
+
+int
+execl(const char *name, const char *arg0, ...)
+{
+	return execve(name, &arg0, environ);
+}
diff --git a/sys/src/ape/lib/ap/plan9/execle.c b/sys/src/ape/lib/ap/plan9/execle.c
new file mode 100755
index 000000000..f607c4914
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execle.c
@@ -0,0 +1,11 @@
+#include <unistd.h>
+
+int
+execle(const char *name, const char *arg0, const char *aore, ...)
+{
+	char *p;
+
+	for(p=(char *)(&name)+1; *p; )
+		p++;
+	return execve(name, &arg0, (char **)p+1);
+}
diff --git a/sys/src/ape/lib/ap/plan9/execlp.c b/sys/src/ape/lib/ap/plan9/execlp.c
new file mode 100755
index 000000000..ff5d71761
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execlp.c
@@ -0,0 +1,24 @@
+#include <unistd.h>
+#include <string.h>
+#include <sys/limits.h>
+
+/*
+ * BUG: instead of looking at PATH env variable,
+ * just try prepending /bin/ if name fails...
+ */
+
+extern char **environ;
+
+int
+execlp(const char *name, const char *arg0, ...)
+{
+	int n;
+	char buf[PATH_MAX];
+
+	if((n=execve(name, &arg0, environ)) < 0){
+		strcpy(buf, "/bin/");
+		strcpy(buf+5, name);
+		n = execve(buf, &name+1, environ);
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/execv.c b/sys/src/ape/lib/ap/plan9/execv.c
new file mode 100755
index 000000000..409e96003
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execv.c
@@ -0,0 +1,9 @@
+#include <unistd.h>
+
+extern char **environ;
+
+int
+execv(const char *name, const char *argv[])
+{
+	return execve(name, argv, environ);
+}
diff --git a/sys/src/ape/lib/ap/plan9/execve.c b/sys/src/ape/lib/ap/plan9/execve.c
new file mode 100755
index 000000000..1d5c3c2fe
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execve.c
@@ -0,0 +1,103 @@
+#include "lib.h"
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include "sys9.h"
+
+extern char **environ;
+
+int
+execve(const char *name, const char *argv[], const char *envp[])
+{
+	int n, f, i;
+	char **e, *ss, *se;
+	Fdinfo *fi;
+	unsigned long flags;
+	char nam[256+5];
+	char buf[1000];
+
+	_RFORK(RFCENVG);
+	/*
+	 * To pass _fdinfo[] across exec, put lines like
+	 *   fd flags oflags
+	 * in $_fdinfo (for open fd's)
+	 */
+
+	f = _CREATE("#e/_fdinfo", OWRITE, 0666);
+	ss = buf;
+	for(n = 0; n<OPEN_MAX; n++){
+		fi = &_fdinfo[n];
+		flags = fi->flags;
+		if(flags&FD_CLOEXEC){
+			_CLOSE(n);
+			fi->flags = 0;
+			fi->oflags = 0;
+		}else if(flags&FD_ISOPEN){
+			ss = _ultoa(ss, n);
+			*ss++ = ' ';
+			ss = _ultoa(ss, flags);
+			*ss++ = ' ';
+			ss = _ultoa(ss, fi->oflags);
+			*ss++ = '\n';
+			if(ss-buf < sizeof(buf)-50){
+				_WRITE(f, buf, ss-buf);
+				ss = buf;
+			}
+		}
+	}
+	if(ss > buf)
+		_WRITE(f, buf, ss-buf);
+	_CLOSE(f);
+	/*
+	 * To pass _sighdlr[] across exec, set $_sighdlr
+	 * to list of blank separated fd's that have
+	 * SIG_IGN (the rest will be SIG_DFL).
+	 * We write the variable, even if no signals
+	 * are ignored, in case the current value of the
+	 * variable ignored some.
+	 */
+	f = _CREATE("#e/_sighdlr", OWRITE, 0666);
+	if(f >= 0){
+		ss = buf;
+		for(i = 0, n=0; i <=MAXSIG && ss < &buf[sizeof(buf)]-5; i++) {
+			if(_sighdlr[i] == SIG_IGN) {
+				ss = _ultoa(ss, i);
+				*ss++ = ' ';
+			}
+		}
+		_WRITE(f, buf, ss-buf);
+		_CLOSE(f);
+	}
+	if(envp){
+		strcpy(nam, "#e/");
+		for(e = envp; (ss = *e); e++) {
+			se = strchr(ss, '=');
+			if(!se || ss==se)
+				continue;	/* what is name? value? */
+			n = se-ss;
+			if(n >= sizeof(nam)-3)
+				n = sizeof(nam)-3-1;
+			memcpy(nam+3, ss, n);
+			nam[3+n] = 0;
+			f = _CREATE(nam, OWRITE, 0666);
+			if(f < 0)
+				continue;
+			se++; /* past = */
+			n = strlen(se);
+			/* temporarily decode nulls (see _envsetup()) */
+			for(i=0; i < n; i++)
+				if(se[i] == 1)
+					se[i] = 0;
+			_WRITE(f, se, n);
+			/* put nulls back */
+			for(i=0; i < n; i++)
+				if(se[i] == 0)
+					se[i] = 1;
+			_CLOSE(f);
+		}
+	}
+	n = _EXEC(name, argv);
+	_syserrno();
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/execvp.c b/sys/src/ape/lib/ap/plan9/execvp.c
new file mode 100755
index 000000000..f2ed53d1d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/execvp.c
@@ -0,0 +1,24 @@
+#include <unistd.h>
+#include <sys/limits.h>
+#include <string.h>
+
+extern char **environ;
+
+/*
+ * BUG: instead of looking at PATH env variable,
+ * just try prepending /bin/ if name fails...
+ */
+
+int
+execvp(const char *name, const char **argv)
+{
+	int n;
+	char buf[PATH_MAX];
+
+	if((n=execve(name, argv, environ)) < 0){
+		strcpy(buf, "/bin/");
+		strcpy(buf+5, name);
+		n = execve(buf, argv, environ);
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/fcall.h b/sys/src/ape/lib/ap/plan9/fcall.h
new file mode 100755
index 000000000..8090a19a4
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/fcall.h
@@ -0,0 +1,118 @@
+typedef	struct	Fcall	Fcall;
+
+/* see /sys/include/auth.h */
+enum
+{
+	DOMLEN=		48,		/* length of an authentication domain name */
+	DESKEYLEN=	7,		/* length of a des key for encrypt/decrypt */
+	CHALLEN=	8,		/* length of a challenge */
+	NETCHLEN=	16,		/* max network challenge length	*/
+	CONFIGLEN=	14,
+
+	KEYDBLEN=	NAMELEN+DESKEYLEN+4+2
+};
+#define	TICKETLEN	(CHALLEN+2*NAMELEN+DESKEYLEN+1)
+#define	AUTHENTLEN	(CHALLEN+4+1)
+
+struct	Fcall
+{
+	char	type;
+	short	fid;
+	unsigned short	tag;
+	union
+	{
+		struct
+		{
+			unsigned short	oldtag;		/* T-Flush */
+			Qid	qid;		/* R-Attach, R-Walk, R-Open, R-Create */
+			char	rauth[AUTHENTLEN];	/* Rattach */
+		};
+		struct
+		{
+			char	uname[NAMELEN];	/* T-Attach */
+			char	aname[NAMELEN];	/* T-Attach */
+			char	ticket[TICKETLEN];	/* T-Attach */
+			char	auth[AUTHENTLEN];/* T-Attach */
+		};
+		struct
+		{
+			char	ename[ERRLEN];	/* R-Error */
+			char	authid[NAMELEN];	/* R-session */
+			char	authdom[DOMLEN];	/* R-session */
+			char	chal[CHALLEN];		/* T-session/R-session */
+		};
+		struct
+		{
+			long	perm;		/* T-Create */ 
+			short	newfid;		/* T-Clone, T-Clwalk */
+			char	name[NAMELEN];	/* T-Walk, T-Clwalk, T-Create */
+			char	mode;		/* T-Create, T-Open */
+		};
+		struct
+		{
+			long	offset;		/* T-Read, T-Write */
+			long	count;		/* T-Read, T-Write, R-Read */
+			char	*data;		/* T-Write, R-Read */
+		};
+		struct
+		{
+			char	stat[DIRLEN];	/* T-Wstat, R-Stat */
+		};
+	};
+};
+
+#define	MAXFDATA	8192
+#define	MAXMSG		160	/* max header sans data */
+#define NOTAG		0xFFFF	/* Dummy tag */
+
+enum
+{
+	Tmux =		48,
+	Rmux,			/* illegal */
+	Tnop =		50,
+	Rnop,
+	Tosession =	52,	/* illegal */
+	Rosession,		/* illegal */
+	Terror =	54,	/* illegal */
+	Rerror,
+	Tflush =	56,
+	Rflush,
+	Toattach =	58,	/* illegal */
+	Roattach,		/* illegal */
+	Tclone =	60,
+	Rclone,
+	Twalk =		62,
+	Rwalk,
+	Topen =		64,
+	Ropen,
+	Tcreate =	66,
+	Rcreate,
+	Tread =		68,
+	Rread,
+	Twrite =	70,
+	Rwrite,
+	Tclunk =	72,
+	Rclunk,
+	Tremove =	74,
+	Rremove,
+	Tstat =		76,
+	Rstat,
+	Twstat =	78,
+	Rwstat,
+	Tclwalk =	80,
+	Rclwalk,
+	Tauth =		82,	/* illegal */
+	Rauth,			/* illegal */
+	Tsession =	84,
+	Rsession,
+	Tattach =	86,
+	Rattach,
+};
+
+int	convM2S(char*, Fcall*, int);
+int	convS2M(Fcall*, char*);
+
+int	convM2D(char*, Dir*);
+int	convD2M(Dir*, char*);
+
+char*	getS(int, char*, Fcall*, long*);
diff --git a/sys/src/ape/lib/ap/plan9/fcntl.c b/sys/src/ape/lib/ap/plan9/fcntl.c
new file mode 100755
index 000000000..053e38ec3
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/fcntl.c
@@ -0,0 +1,81 @@
+#include "lib.h"
+#include <unistd.h>
+#include <errno.h>
+#include <stdarg.h>
+#include "sys9.h"
+
+/*
+ * BUG: advisory locking not implemented
+ */
+
+#define OFL (O_ACCMODE|O_NONBLOCK|O_APPEND)
+
+int
+fcntl(int fd, int cmd, ...)
+{
+	int arg, i, ans, err;
+	Fdinfo *fi, *fans;
+	va_list va;
+	unsigned long oflags;
+
+	err = 0;
+	ans = 0;
+	va_start(va, cmd);
+	arg = va_arg(va, int);
+	va_end(va);
+	fi = &_fdinfo[fd];
+	if(fd<0 || fd>=OPEN_MAX || !(fi->flags&FD_ISOPEN))
+		err = EBADF;
+	else switch(cmd){
+		case F_DUPFD:
+			if(fi->flags&(FD_BUFFERED|FD_BUFFEREDX)){
+				err = EGREG;	/* dup of buffered fd not implemented */
+				break;
+			}
+			oflags = fi->oflags;
+			for(i = (arg>0)? arg : 0; i<OPEN_MAX; i++)
+				if(!(_fdinfo[i].flags&FD_ISOPEN))
+					break;
+			if(i == OPEN_MAX)
+				err = EMFILE;
+			else {
+				ans = _DUP(fd, i);
+				if(ans != i){
+					if(ans < 0){
+						_syserrno();
+						err = errno;
+					}else
+						err = EBADF;
+				}else{
+					fans = &_fdinfo[ans];
+					fans->flags = fi->flags&~FD_CLOEXEC;
+					fans->oflags = oflags;
+					fans->uid = fi->uid;
+					fans->gid = fi->gid;
+				}
+			}
+			break;
+		case F_GETFD:
+			ans = fi->flags&FD_CLOEXEC;
+			break;
+		case F_SETFD:
+			fi->flags = (fi->flags&~FD_CLOEXEC)|(arg&FD_CLOEXEC);
+			break;
+		case F_GETFL:
+			ans = fi->oflags&OFL;
+			break;
+		case F_SETFL:
+			fi->oflags = (fi->oflags&~OFL)|(arg&OFL);
+			break;
+		case F_GETLK:
+		case F_SETLK:
+		case F_SETLKW:
+			err = EINVAL;
+			break;
+		}
+	if(err){
+		errno = err;
+		ans = -1;
+	}
+	return ans;
+}
diff --git a/sys/src/ape/lib/ap/plan9/fork.c b/sys/src/ape/lib/ap/plan9/fork.c
new file mode 100755
index 000000000..8137bc688
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/fork.c
@@ -0,0 +1,19 @@
+#include "lib.h"
+#include <errno.h>
+#include <unistd.h>
+#include "sys9.h"
+
+pid_t
+fork(void)
+{
+	int n;
+
+	n = _RFORK(RFENVG|RFFDG|RFPROC);
+	if(n < 0)
+		_syserrno();
+	if(n == 0) {
+		_detachbuf();
+		_sessleader = 0;
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/frexp.c b/sys/src/ape/lib/ap/plan9/frexp.c
new file mode 100755
index 000000000..588f90cee
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/frexp.c
@@ -0,0 +1,89 @@
+#include <math.h>
+#include <errno.h>
+#define _RESEARCH_SOURCE
+#include <float.h>
+
+#define	MASK	0x7ffL
+#define	SHIFT	20
+#define	BIAS	1022L
+
+typedef	union
+{
+	double	d;
+	struct
+	{
+#ifdef IEEE_8087
+		long	ls;
+		long	ms;
+#else
+		long	ms;
+		long	ls;
+#endif
+	};
+} Cheat;
+
+double
+frexp(double d, int *ep)
+{
+	Cheat x;
+
+	if(d == 0) {
+		*ep = 0;
+		return 0;
+	}
+	x.d = d;
+	*ep = ((x.ms >> SHIFT) & MASK) - BIAS;
+	x.ms &= ~(MASK << SHIFT);
+	x.ms |= BIAS << SHIFT;
+	return x.d;
+}
+
+double
+ldexp(double d, int e)
+{
+	Cheat x;
+
+	if(d == 0)
+		return 0;
+	x.d = d;
+	e += (x.ms >> SHIFT) & MASK;
+	if(e <= 0)
+		return 0;
+	if(e >= MASK){
+		errno = ERANGE;
+		if(d < 0)
+			return -HUGE_VAL;
+		return HUGE_VAL;
+	}
+	x.ms &= ~(MASK << SHIFT);
+	x.ms |= (long)e << SHIFT;
+	return x.d;
+}
+
+double
+modf(double d, double *ip)
+{
+	double f;
+	Cheat x;
+	int e;
+
+	if(d < 1) {
+		if(d < 0) {
+			f = modf(-d, ip);
+			*ip = -*ip;
+			return -f;
+		}
+		*ip = 0;
+		return d;
+	}
+	x.d = d;
+	e = ((x.ms >> SHIFT) & MASK) - BIAS;
+	if(e <= SHIFT+1) {
+		x.ms &= ~(0x1fffffL >> e);
+		x.ls = 0;
+	} else
+	if(e <= SHIFT+33)
+		x.ls &= ~(0x7fffffffL >> (e-SHIFT-2));
+	*ip = x.d;
+	return d - x.d;
+}
diff --git a/sys/src/ape/lib/ap/plan9/fstat.c b/sys/src/ape/lib/ap/plan9/fstat.c
new file mode 100755
index 000000000..62e6c653a
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/fstat.c
@@ -0,0 +1,20 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+fstat(int fd, struct stat *buf)
+{
+	Dir *d;
+
+	if((d = _dirfstat(fd)) == nil){
+		_syserrno();
+		return -1;
+	}
+	_dirtostat(buf, d, &_fdinfo[fd]);
+	free(d);
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/fsync.c b/sys/src/ape/lib/ap/plan9/fsync.c
new file mode 100755
index 000000000..f37d35c04
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/fsync.c
@@ -0,0 +1,10 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+int
+fsync(int fd)
+{
+	errno = EINVAL;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/ftruncate.c b/sys/src/ape/lib/ap/plan9/ftruncate.c
new file mode 100755
index 000000000..aa867488c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/ftruncate.c
@@ -0,0 +1,23 @@
+#include "lib.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include "dir.h"
+
+int
+ftruncate(int fd, off_t length)
+{
+	Dir d;
+
+	if(length < 0){
+		errno = EINVAL;
+		return -1;
+	}
+	_nulldir(&d);
+	d.length = length;
+	if(_dirfwstat(fd, &d) < 0){
+		_syserrno();
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getcwd.c b/sys/src/ape/lib/ap/plan9/getcwd.c
new file mode 100755
index 000000000..db6936b56
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getcwd.c
@@ -0,0 +1,32 @@
+#include "lib.h"
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include "sys9.h"
+#include "dir.h"
+
+char*
+getcwd(char *buf, size_t len)
+{
+	int fd;
+
+	fd = _OPEN(".", OREAD);
+	if(fd < 0) {
+		errno = EACCES;
+		return 0;
+	}
+	if(_FD2PATH(fd, buf, len) < 0) {
+		errno = EIO;
+		_CLOSE(fd);
+		return 0;
+	}
+	_CLOSE(fd);
+
+/* RSC: is this necessary? */
+	if(buf[0] == '\0')
+		strcpy(buf, "/");
+	return buf;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getgid.c b/sys/src/ape/lib/ap/plan9/getgid.c
new file mode 100755
index 000000000..e1f5fc39b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getgid.c
@@ -0,0 +1,21 @@
+#include <sys/types.h>
+#include <grp.h>
+#include <unistd.h>
+
+/*
+ * BUG: assumes group that is same as user name
+ * is the one wanted (plan 9 has no "current group")
+ */
+gid_t
+getgid(void)
+{
+	struct group *g;
+	g = getgrnam(getlogin());
+	return g? g->gr_gid : 1;
+}
+
+gid_t
+getegid(void)
+{
+	return getgid();
+}
diff --git a/sys/src/ape/lib/ap/plan9/getgrgid.c b/sys/src/ape/lib/ap/plan9/getgrgid.c
new file mode 100755
index 000000000..77e2997fa
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getgrgid.c
@@ -0,0 +1,25 @@
+#include <stddef.h>
+#include <grp.h>
+
+extern int _getpw(int *, char **, char **);
+extern char **_grpmems(char *);
+
+static struct group holdgroup;
+
+struct group *
+getgrgid(gid_t gid)
+{
+	int num;
+	char *nam, *mem;
+
+	num = gid;
+	nam = 0;
+	mem = 0;
+	if(_getpw(&num, &nam, &mem)){
+		holdgroup.gr_name = nam;
+		holdgroup.gr_gid = num;
+		holdgroup.gr_mem = _grpmems(mem);
+		return &holdgroup;
+	}
+	return NULL;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getgrnam.c b/sys/src/ape/lib/ap/plan9/getgrnam.c
new file mode 100755
index 000000000..7033120e4
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getgrnam.c
@@ -0,0 +1,25 @@
+#include <stddef.h>
+#include <grp.h>
+
+extern int _getpw(int *, char **, char **);
+extern char **_grpmems(char *);
+
+static struct group holdgroup;
+
+struct group *
+getgrnam(const char *name)
+{
+	int num;
+	char *nam, *mem;
+
+	num = 0;
+	nam = name;
+	mem = 0;
+	if(_getpw(&num, &nam, &mem)){
+		holdgroup.gr_name = nam;
+		holdgroup.gr_gid = num;
+		holdgroup.gr_mem = _grpmems(mem);
+		return &holdgroup;
+	}
+	return NULL;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getgroups.c b/sys/src/ape/lib/ap/plan9/getgroups.c
new file mode 100755
index 000000000..e226a65b4
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getgroups.c
@@ -0,0 +1,10 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+int
+getgroups(int gidsize, gid_t grouplist[])
+{
+	errno = EINVAL;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getlogin.c b/sys/src/ape/lib/ap/plan9/getlogin.c
new file mode 100755
index 000000000..8d2d51ce0
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getlogin.c
@@ -0,0 +1,27 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/limits.h>
+
+char *
+getlogin_r(char *buf, int len)
+{
+	int f, n;
+
+	f = open("/dev/user", O_RDONLY);
+	if(f < 0)
+		return 0;
+	n = read(f, buf, len);
+	buf[len-1] = 0;
+	close(f);
+	return (n>=0)? buf : 0;
+}
+
+char *
+getlogin(void)
+{
+	static char buf[NAME_MAX+1];
+
+	return getlogin_r(buf, sizeof buf);
+}
diff --git a/sys/src/ape/lib/ap/plan9/getpgrp.c b/sys/src/ape/lib/ap/plan9/getpgrp.c
new file mode 100755
index 000000000..310028784
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getpgrp.c
@@ -0,0 +1,27 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include "sys9.h"
+#include "lib.h"
+
+pid_t
+getpgrp(void)
+{
+	int n, f, pid;
+	char pgrpbuf[15], fname[30];
+
+	pid = getpid();
+	sprintf(fname, "/proc/%d/noteid", pid);
+	f = open(fname, 0);
+	n = read(f, pgrpbuf, sizeof pgrpbuf);
+	if(n < 0)
+		_syserrno();
+	else
+		n = atoi(pgrpbuf);
+	close(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getpid.c b/sys/src/ape/lib/ap/plan9/getpid.c
new file mode 100755
index 000000000..66eaaae8d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getpid.c
@@ -0,0 +1,22 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include "sys9.h"
+
+pid_t
+getpid(void)
+{
+	int n, f;
+	char pidbuf[15];
+
+	f = _OPEN("#c/pid", 0);
+	n = _READ(f, pidbuf, sizeof pidbuf);
+	if(n < 0)
+		_syserrno();
+	else
+		n = atoi(pidbuf);
+	_CLOSE(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getppid.c b/sys/src/ape/lib/ap/plan9/getppid.c
new file mode 100755
index 000000000..01759221b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getppid.c
@@ -0,0 +1,23 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include "sys9.h"
+
+pid_t
+getppid(void)
+{
+	int n, f;
+	char ppidbuf[15];
+
+	f = open("#c/ppid", 0);
+	n = read(f, ppidbuf, sizeof ppidbuf);
+	if(n < 0)
+		errno = EINVAL;
+	else
+		n = atoi(ppidbuf);
+	close(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getpwnam.c b/sys/src/ape/lib/ap/plan9/getpwnam.c
new file mode 100755
index 000000000..e9d1c5b4e
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getpwnam.c
@@ -0,0 +1,29 @@
+#include "lib.h"
+#include <stddef.h>
+#include <pwd.h>
+#include <string.h>
+
+static struct passwd holdpw;
+static char dirbuf[40] = "/usr/";
+static char *rc = "/bin/rc";
+
+struct passwd *
+getpwnam(const char *name)
+{
+	int num;
+	char *nam, *mem;
+
+	num = 0;
+	nam = name;
+	mem = 0;
+	if(_getpw(&num, &nam, &mem)){
+		holdpw.pw_name = nam;
+		holdpw.pw_uid = num;
+		holdpw.pw_gid = num;
+		strncpy(dirbuf+5, nam, sizeof(dirbuf)-6);
+		holdpw.pw_dir = dirbuf;
+		holdpw.pw_shell = rc;
+		return &holdpw;
+	}
+	return NULL;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getpwuid.c b/sys/src/ape/lib/ap/plan9/getpwuid.c
new file mode 100755
index 000000000..e2983765b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getpwuid.c
@@ -0,0 +1,30 @@
+#include <stddef.h>
+#include <pwd.h>
+#include <string.h>
+
+extern int _getpw(int *, char **, char **);
+
+static struct passwd holdpw;
+static char dirbuf[40] = "/usr/";
+static char *rc = "/bin/rc";
+
+struct passwd *
+getpwuid(uid_t uid)
+{
+	int num;
+	char *nam, *mem;
+
+	num = uid;
+	nam = 0;
+	mem = 0;
+	if(_getpw(&num, &nam, &mem)){
+		holdpw.pw_name = nam;
+		holdpw.pw_uid = num;
+		holdpw.pw_gid = num;
+		strncpy(dirbuf+5, nam, sizeof(dirbuf)-6);
+		holdpw.pw_dir = dirbuf;
+		holdpw.pw_shell = rc;
+		return &holdpw;
+	}
+	return NULL;
+}
diff --git a/sys/src/ape/lib/ap/plan9/getuid.c b/sys/src/ape/lib/ap/plan9/getuid.c
new file mode 100755
index 000000000..05d4c0832
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/getuid.c
@@ -0,0 +1,17 @@
+#include <sys/types.h>
+#include <pwd.h>
+#include <unistd.h>
+
+uid_t
+getuid(void)
+{
+	struct passwd *p;
+	p = getpwnam(getlogin());
+	return p? p->pw_uid : 1;
+}
+
+uid_t
+geteuid(void)
+{
+	return getuid();
+}
diff --git a/sys/src/ape/lib/ap/plan9/isatty.c b/sys/src/ape/lib/ap/plan9/isatty.c
new file mode 100755
index 000000000..e04cd891d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/isatty.c
@@ -0,0 +1,29 @@
+#include "lib.h"
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+_isatty(int fd)
+{
+	int t;
+	char buf[64];
+
+	if(_FD2PATH(fd, buf, sizeof buf) < 0)
+		return 0;
+
+	/* might be /mnt/term/dev/cons */
+	return strlen(buf) >= 9 && strcmp(buf+strlen(buf)-9, "/dev/cons") == 0;
+}
+
+/* The FD_ISTTY flag is set via _isatty in _fdsetup or open */
+int
+isatty(fd)
+{
+	if(_fdinfo[fd].flags&FD_ISTTY)
+		return 1;
+	else
+		return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/kill.c b/sys/src/ape/lib/ap/plan9/kill.c
new file mode 100755
index 000000000..95bbbdcc7
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/kill.c
@@ -0,0 +1,60 @@
+#include "lib.h"
+#include <fcntl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+static int
+note(int pid, char *msg, char *fmt)
+{
+	int f;
+	char pname[50];
+
+	sprintf(pname, fmt, pid);
+	f = open(pname, O_WRONLY);
+	if(f < 0){
+		errno = ESRCH;
+		return -1;
+	}
+	if(msg != 0 && write(f, msg, strlen(msg)) < 0){
+		close(f);
+		errno = EPERM;
+		return -1;
+	}
+	close(f);
+	return 0;
+}
+
+int
+kill(pid_t pid, int sig)
+{
+	char *msg;
+	int sid, r, mpid;
+
+	if(sig == 0)
+		msg = 0;
+	else {
+		msg = _sigstring(sig);
+		if(msg == 0) {
+			errno = EINVAL;
+			return -1;
+		} 
+	}
+
+	if(pid < 0) {
+		sid = getpgrp();
+		mpid = getpid();
+		if(setpgid(mpid, -pid) == 0) {
+			r = note(mpid, msg, "/proc/%d/notepg");
+			setpgid(mpid, sid);
+		} else {
+			r = -1;
+		}
+	} else if(pid == 0)
+		r = note(getpid(), msg, "/proc/%d/notepg");
+	else
+		r = note(pid, msg, "/proc/%d/note");
+	return r;
+}
diff --git a/sys/src/ape/lib/ap/plan9/lib.h b/sys/src/ape/lib/ap/plan9/lib.h
new file mode 100755
index 000000000..91a51d5d3
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/lib.h
@@ -0,0 +1,72 @@
+#include <sys/types.h>
+#include <sys/limits.h>
+#include <fcntl.h>
+#include <ureg.h>
+
+typedef struct Ureg Ureg;
+
+/* mux buf for selecting (see _buf.c) */
+enum {
+	READMAX = 8192,			/* read at most this much with _READ */
+	PERFDMAX = 2*READMAX,		/* stop _READing an fd when it has this much */
+	INITBUFS = 4,			/* allow enough room for this many PERFDMAX */
+};
+
+typedef struct Muxbuf {
+	int n;				/* # unprocessed chars in buf */
+	unsigned char*	putnext;	/* place for copy process to put next data */
+	unsigned char*	getnext;	/* place for parent process to get next data */
+	char		fd;		/* fd for which this is a buffer */
+	unsigned char	eof;		/* true if eof after current data exhausted */
+	unsigned char	roomwait;	/* true if copy process is waiting for room */
+	unsigned char	datawait;	/* true if parent process is waiting for data */
+	int		copypid;	/* pid of copyproc */
+	unsigned char	data[PERFDMAX];
+} Muxbuf;
+
+/* be sure to change _fdinfo[] init in _fdinfo if you change this */
+typedef struct Fdinfo{
+	unsigned long	flags;
+	unsigned long	oflags;
+	uid_t	uid;
+	gid_t	gid;	
+	char		*name;
+	/*
+	 * the following is used if flags&FD_BUFFERED
+	 */
+	Muxbuf	*buf;	/* holds buffered data and state */
+} Fdinfo;
+
+/* #define FD_CLOEXEC 1 is in fcntl.h */
+
+#define FD_ISOPEN	0x2
+#define FD_BUFFERED	0x4
+#define FD_BUFFEREDX	0x8
+#define FD_ISTTY	0x20
+
+#define MAXSIG SIGUSR2
+
+extern Fdinfo	_fdinfo[];
+
+extern int	_finishing;
+extern int	_sessleader;
+extern void	(*_sighdlr[])(int, char*, Ureg*);
+extern char	*_sigstring(int);
+extern int	_stringsig(char *);
+extern long	_psigblocked;
+extern int	_startbuf(int);
+extern int	_selbuf(int);
+extern void	_closebuf(int);
+extern int _readbuf(int, void*, int, int);
+extern void	_detachbuf(void);
+extern void	_finish(int, char *);
+extern char	*_ultoa(char *, unsigned long);
+extern int	_notehandler(void *, char *);
+extern void	_notetramp(int, void (*)(int, char*, Ureg*), Ureg*);
+extern void	_syserrno(void);
+extern int	_getpw(int *, char **, char **);
+extern int _isatty(int);
+extern void _fdinit(char*, char*);
+
+
+void checkbug(char *, int);
diff --git a/sys/src/ape/lib/ap/plan9/link.c b/sys/src/ape/lib/ap/plan9/link.c
new file mode 100755
index 000000000..9bf3755fb
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/link.c
@@ -0,0 +1,12 @@
+#include <unistd.h>
+#include <errno.h>
+
+/*
+ * BUG: LINK_MAX==1 isn't really allowed
+ */
+int
+link(const char *name1, const char *name2)
+{
+	errno = EMLINK;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/lseek.c b/sys/src/ape/lib/ap/plan9/lseek.c
new file mode 100755
index 000000000..8c4eba39d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/lseek.c
@@ -0,0 +1,24 @@
+#include "lib.h"
+#include <unistd.h>
+#include <errno.h>
+#include "sys9.h"
+
+/*
+ * BUG: errno mapping
+ */
+off_t
+lseek(int d, off_t offset, int whence)
+{
+	long long n;
+	int flags;
+
+	flags = _fdinfo[d].flags;
+	if(flags&(FD_BUFFERED|FD_BUFFEREDX|FD_ISTTY)) {
+		errno = ESPIPE;
+		return -1;
+	}
+	n = _SEEK(d, offset, whence);
+	if(n < 0)
+		_syserrno();
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/malloc.c b/sys/src/ape/lib/ap/plan9/malloc.c
new file mode 100755
index 000000000..09f3c178e
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/malloc.c
@@ -0,0 +1,142 @@
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned int	uint;
+
+enum
+{
+	MAGIC		= 0xbada110c,
+	MAX2SIZE	= 32,
+	CUTOFF		= 12,
+};
+
+typedef struct Bucket Bucket;
+struct Bucket
+{
+	int	size;
+	int	magic;
+	Bucket	*next;
+	int	pad;
+	char	data[1];
+};
+
+typedef struct Arena Arena;
+struct Arena
+{
+	Bucket	*btab[MAX2SIZE];	
+};
+static Arena arena;
+
+#define datoff		((int)((Bucket*)0)->data)
+#define nil		((void*)0)
+
+extern	void	*sbrk(unsigned long);
+
+void*
+malloc(size_t size)
+{
+	uint next;
+	int pow, n;
+	Bucket *bp, *nbp;
+
+	for(pow = 1; pow < MAX2SIZE; pow++) {
+		if(size <= (1<<pow))
+			goto good;
+	}
+
+	return nil;
+good:
+	/* Allocate off this list */
+	bp = arena.btab[pow];
+	if(bp) {
+		arena.btab[pow] = bp->next;
+
+		if(bp->magic != 0)
+			abort();
+
+		bp->magic = MAGIC;
+		return  bp->data;
+	}
+	size = sizeof(Bucket)+(1<<pow);
+	size += 7;
+	size &= ~7;
+
+	if(pow < CUTOFF) {
+		n = (CUTOFF-pow)+2;
+		bp = sbrk(size*n);
+		if((int)bp < 0)
+			return nil;
+
+		next = (uint)bp+size;
+		nbp = (Bucket*)next;
+		arena.btab[pow] = nbp;
+		for(n -= 2; n; n--) {
+			next = (uint)nbp+size;
+			nbp->next = (Bucket*)next;
+			nbp->size = pow;
+			nbp = nbp->next;
+		}
+		nbp->size = pow;
+	}
+	else {
+		bp = sbrk(size);
+		if((int)bp < 0)
+			return nil;
+	}
+		
+	bp->size = pow;
+	bp->magic = MAGIC;
+
+	return bp->data;
+}
+
+void
+free(void *ptr)
+{
+	Bucket *bp, **l;
+
+	if(ptr == nil)
+		return;
+
+	/* Find the start of the structure */
+	bp = (Bucket*)((uint)ptr - datoff);
+
+	if(bp->magic != MAGIC)
+		abort();
+
+	bp->magic = 0;
+	l = &arena.btab[bp->size];
+	bp->next = *l;
+	*l = bp;
+}
+
+void*
+realloc(void *ptr, size_t n)
+{
+	void *new;
+	uint osize;
+	Bucket *bp;
+
+	if(ptr == nil)
+		return malloc(n);
+
+	/* Find the start of the structure */
+	bp = (Bucket*)((uint)ptr - datoff);
+
+	if(bp->magic != MAGIC)
+		abort();
+
+	/* enough space in this bucket */
+	osize = 1<<bp->size;
+	if(osize >= n)
+		return ptr;
+
+	new = malloc(n);
+	if(new == nil)
+		return nil;
+
+	memmove(new, ptr, osize);
+	free(ptr);
+
+	return new;
+}
diff --git a/sys/src/ape/lib/ap/plan9/mkdir.c b/sys/src/ape/lib/ap/plan9/mkdir.c
new file mode 100755
index 000000000..1773150b5
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/mkdir.c
@@ -0,0 +1,27 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <errno.h>
+#include "sys9.h"
+
+/*
+ * BUG: errno mapping
+ */
+int
+mkdir(const char *name, mode_t mode)
+{
+	int n;
+	struct stat st;
+
+	if(stat(name, &st)==0) {
+		errno = EEXIST;
+		return -1;
+	}
+	n = _CREATE(name, 0, 0x80000000|(mode&0777));
+	if(n < 0)
+		_syserrno();
+	else{
+		_CLOSE(n);
+		n = 0;
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/mkfile b/sys/src/ape/lib/ap/plan9/mkfile
new file mode 100755
index 000000000..502d00f8b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/mkfile
@@ -0,0 +1,110 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	_buf.$O\
+	_dirconv.$O\
+	_envsetup.$O\
+	_errno.$O\
+	_exit.$O\
+	_fdinfo.$O\
+	_getpw.$O\
+	_nap.$O\
+	9mallocz.$O\
+	9iounit.$O\
+	9read.$O\
+	9readn.$O\
+	9wait.$O\
+	9write.$O\
+	access.$O\
+	alarm.$O\
+	brk.$O\
+	cfgetospeed.$O\
+	chdir.$O\
+	chmod.$O\
+	chown.$O\
+	close.$O\
+	convM2D.$O\
+	convD2M.$O\
+	creat.$O\
+	ctermid.$O\
+	ctime.$O\
+	cuserid.$O\
+	dirread.$O\
+	dirstat.$O\
+	dirtostat.$O\
+	dup.$O\
+	execl.$O\
+	execle.$O\
+	execlp.$O\
+	execv.$O\
+	execve.$O\
+	execvp.$O\
+	fcntl.$O\
+	fork.$O\
+	frexp.$O\
+	fstat.$O\
+	fsync.$O\
+	ftruncate.$O\
+	getcwd.$O\
+	getgid.$O\
+	getgrgid.$O\
+	getgrnam.$O\
+	getgroups.$O\
+	getlogin.$O\
+	getpgrp.$O\
+	getpid.$O\
+	getppid.$O\
+	getpwnam.$O\
+	getpwuid.$O\
+	getuid.$O\
+	isatty.$O\
+	kill.$O\
+	link.$O\
+	lseek.$O\
+	malloc.$O\
+	mkdir.$O\
+	nan.$O\
+	open.$O\
+	opendir.$O\
+	pause.$O\
+	pipe.$O\
+	profile.$O\
+	qlock.$O\
+	read.$O\
+	rename.$O\
+	rmdir.$O\
+	setgid.$O\
+	setpgid.$O\
+	setsid.$O\
+	setuid.$O\
+	signal.$O\
+	sigpending.$O\
+	sigprocmask.$O\
+	sigsuspend.$O\
+	sleep.$O\
+	sqrt.$O\
+	stat.$O\
+	system.$O\
+	tcgetattr.$O\
+	time.$O\
+	times.$O\
+	tmpfile.$O\
+	ttyname.$O\
+	umask.$O\
+	uname.$O\
+	unlink.$O\
+	utime.$O\
+	wait.$O\
+	write.$O\
+
+UPDATE=\
+	mkfile\
+	/386/lib/ape/libap.a\
+	${OFILES:%.$O=%.c}\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE -D_BSD_EXTENSION
+
+$OFILES: lib.h
diff --git a/sys/src/ape/lib/ap/plan9/nan.c b/sys/src/ape/lib/ap/plan9/nan.c
new file mode 100755
index 000000000..db7c13fe8
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/nan.c
@@ -0,0 +1,54 @@
+#include <float.h>
+#include <math.h>
+
+#define	NANEXP	(2047<<20)
+#define	NANMASK	(2047<<20)
+#define	NANSIGN	(1<<31)
+
+double
+NaN(void)
+{
+	FPdbleword a;
+
+	a.hi = NANEXP;
+	a.lo = 1;
+	return a.x;
+}
+
+int
+isNaN(double d)
+{
+	FPdbleword a;
+
+	a.x = d;
+	if((a.hi & NANMASK) != NANEXP)
+		return 0;
+	return !isInf(d, 0);
+}
+
+double
+Inf(int sign)
+{
+	FPdbleword a;
+
+	a.hi = NANEXP;
+	a.lo = 0;
+	if(sign < 0)
+		a.hi |= NANSIGN;
+	return a.x;
+}
+
+int
+isInf(double d, int sign)
+{
+	FPdbleword a;
+
+	a.x = d;
+	if(a.lo != 0)
+		return 0;
+	if(a.hi == NANEXP)
+		return sign >= 0;
+	if(a.hi == (NANEXP|NANSIGN))
+		return sign <= 0;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/open.c b/sys/src/ape/lib/ap/plan9/open.c
new file mode 100755
index 000000000..1cfe0d6b5
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/open.c
@@ -0,0 +1,62 @@
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include "lib.h"
+#include <sys/stat.h>
+#include "sys9.h"
+
+/*
+ * O_NOCTTY has no effect
+ */
+int
+open(const char *path, int flags, ...)
+{
+	int n;
+	long f;
+	int mode;
+	Fdinfo *fi;
+	va_list va;
+	struct stat sbuf;
+
+	f = flags&O_ACCMODE;
+	if(flags&O_CREAT){
+		if(access(path, 0) >= 0){
+			if(flags&O_EXCL){
+				errno = EEXIST;
+				return -1;
+			}else{
+				if((flags&O_TRUNC)&&(flags&(O_RDWR|O_WRONLY)))
+					f |= 16;
+				n = _OPEN(path, f);
+			}
+		}else{
+			va_start(va, flags);
+			mode = va_arg(va, int);
+			va_end(va);
+			n = _CREATE(path, f, mode&0777);
+		}
+		if(n < 0)
+			_syserrno();
+	}else{
+		if((flags&O_TRUNC)&&(flags&(O_RDWR|O_WRONLY)))
+			f |= 16;
+		n = _OPEN(path, f);
+		if(n < 0)
+			_syserrno();
+	}
+	if(n >= 0){
+		fi = &_fdinfo[n];
+		fi->flags = FD_ISOPEN;
+		fi->oflags = flags&(O_ACCMODE|O_NONBLOCK|O_APPEND);
+		fi->uid = -2;
+		fi->gid = -2;
+		fi->name = malloc(strlen(path)+1);
+		if(fi->name)
+			strcpy(fi->name, path);
+		if(fi->oflags&O_APPEND)
+			_SEEK(n, 0, 2);
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/opendir.c b/sys/src/ape/lib/ap/plan9/opendir.c
new file mode 100755
index 000000000..ebc22dbf6
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/opendir.c
@@ -0,0 +1,121 @@
+#include "lib.h"
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "sys9.h"
+#include "dir.h"
+
+#define DBLOCKSIZE 20
+
+DIR *
+opendir(const char *filename)
+{
+	int f;
+	DIR *d;
+	struct stat sb;
+	Dir *d9;
+
+	if((d9 = _dirstat(filename)) == nil){
+		_syserrno();
+		return NULL;
+	}
+	_dirtostat(&sb, d9, 0);
+	free(d9);
+	if(S_ISDIR(sb.st_mode) == 0) {
+		errno = ENOTDIR;
+		return NULL;
+	}
+
+	f = open(filename, O_RDONLY);
+	if(f < 0){
+		_syserrno();
+		return NULL;
+	}
+	_fdinfo[f].flags |= FD_CLOEXEC;
+	d = (DIR *)malloc(sizeof(DIR) + DBLOCKSIZE*sizeof(struct dirent));
+	if(!d){
+		errno = ENOMEM;
+		return NULL;
+	}
+	d->dd_buf = (char *)d + sizeof(DIR);
+	d->dd_fd = f;
+	d->dd_loc = 0;
+	d->dd_size = 0;
+	d->dirs = nil;
+	d->dirsize = 0;
+	d->dirloc = 0;
+	return d;
+}
+
+int
+closedir(DIR *d)
+{
+	if(!d){
+		errno = EBADF;
+		return -1;
+	}
+	if(close(d->dd_fd) < 0)
+		return -1;
+	free(d->dirs);
+	free(d);
+	return 0;
+}
+
+void
+rewinddir(DIR *d)
+{
+	if(!d)
+		return;
+	d->dd_loc = 0;
+	d->dd_size = 0;
+	d->dirsize = 0;
+	d->dirloc = 0;
+	free(d->dirs);
+	d->dirs = nil;
+	if(_SEEK(d->dd_fd, 0, 0) < 0){
+		_syserrno();
+		return;
+	}
+}
+
+struct dirent *
+readdir(DIR *d)
+{
+	int i, n;
+	struct dirent *dr;
+	Dir *dirs;
+
+	if(!d){
+		errno = EBADF;
+		return NULL;
+	}
+	if(d->dd_loc >= d->dd_size){
+		if(d->dirloc >= d->dirsize){
+			free(d->dirs);
+			d->dirs = NULL;
+			d->dirsize = _dirread(d->dd_fd, &d->dirs);
+			d->dirloc = 0;
+		}
+		if(d->dirsize < 0) {	/* malloc or read failed in _dirread? */
+			free(d->dirs);
+			d->dirs = NULL;
+		}
+		if(d->dirs == NULL)
+			return NULL;
+
+		dr = (struct dirent *)d->dd_buf;
+		dirs = d->dirs;
+		for(i=0; i<DBLOCKSIZE && d->dirloc < d->dirsize; i++){
+			strncpy(dr[i].d_name, dirs[d->dirloc++].name, MAXNAMLEN);
+			dr[i].d_name[MAXNAMLEN] = 0;
+		}
+		d->dd_loc = 0;
+		d->dd_size = i*sizeof(struct dirent);
+	}
+	dr = (struct dirent*)(d->dd_buf+d->dd_loc);
+	d->dd_loc += sizeof(struct dirent);
+	return dr;
+}
diff --git a/sys/src/ape/lib/ap/plan9/pause.c b/sys/src/ape/lib/ap/plan9/pause.c
new file mode 100755
index 000000000..38fd96162
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/pause.c
@@ -0,0 +1,11 @@
+#include "lib.h"
+#include <unistd.h>
+#include "sys9.h"
+
+int
+pause(void)
+{
+	for(;;)
+		if(_SLEEP(1000*1000) < 0)
+			return;
+}
diff --git a/sys/src/ape/lib/ap/plan9/pipe.c b/sys/src/ape/lib/ap/plan9/pipe.c
new file mode 100755
index 000000000..edc2372e8
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/pipe.c
@@ -0,0 +1,31 @@
+#include <errno.h>
+#include "lib.h"
+#include "sys9.h"
+
+int
+pipe(int fildes[2])
+{
+	Fdinfo *fi;
+	int i;
+
+	if(!fildes){
+		errno = EFAULT;
+		return -1;
+	}
+	if(_PIPE(fildes) < 0)
+		_syserrno();
+	else
+	if(fildes[0] < 0 || fildes[0]>=OPEN_MAX ||
+	   fildes[1] < 0 || fildes[1]>=OPEN_MAX) {
+		errno = EMFILE;
+		return -1;
+	}
+	for(i = 0; i <=1; i++) {
+		fi = &_fdinfo[fildes[i]];
+		fi->flags = FD_ISOPEN;
+		fi->oflags = O_RDWR;
+		fi->uid = 0;	/* none */
+		fi->gid = 0;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/profile.c b/sys/src/ape/lib/ap/plan9/profile.c
new file mode 100755
index 000000000..a69e65f2b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/profile.c
@@ -0,0 +1,324 @@
+#include	<stdio.h>
+#include	<stdlib.h>
+#include	<string.h>
+#include	<unistd.h>
+#include	<errno.h>
+#include	<sys/types.h>
+#include	<fcntl.h>
+#include	"sys9.h"
+
+enum {
+	Profoff,			/* No profiling */
+	Profuser,			/* Measure user time only (default) */
+	Profkernel,			/* Measure user + kernel time */
+	Proftime,			/* Measure total time */
+	Profsample,			/* Use clock interrupt to sample (default when there is no cycle counter) */
+}; /* what */
+
+typedef long long vlong;
+typedef unsigned long ulong;
+typedef unsigned long long uvlong;
+
+#include	"/sys/include/tos.h"
+
+extern	void*	sbrk(ulong);
+extern	long	_callpc(void**);
+extern	long	_savearg(void);
+extern	void	_cycles(uvlong*);	/* 64-bit value of the cycle counter if there is one, 0 if there isn't */
+
+static ulong	khz;
+static ulong	perr;
+static int	havecycles;
+
+typedef	struct	Plink	Plink;
+struct	Plink
+{
+	Plink	*old;
+	Plink	*down;
+	Plink	*link;
+	long	pc;
+	long	count;
+	vlong	time;
+};
+
+#pragma profile off
+
+ulong
+_profin(void)
+{
+	void *dummy;
+	long pc;
+	Plink *pp, *p;
+	ulong arg;
+	vlong t;
+
+	arg = _savearg();
+	pc = _callpc(&dummy);
+	pp = _tos->prof.pp;
+	if(pp == 0 || (_tos->prof.pid && _tos->pid != _tos->prof.pid))
+		return arg;
+
+	for(p=pp->down; p; p=p->link)
+		if(p->pc == pc)
+			goto out;
+	p = _tos->prof.next + 1;
+	if(p >= _tos->prof.last){
+		_tos->prof.pp = 0;
+		perr++;
+		return arg;
+	}
+	_tos->prof.next = p;
+	p->link = pp->down;
+	pp->down = p;
+	p->pc = pc;
+	p->old = pp;
+	p->down = 0;
+	p->count = 0;
+	p->time = 0LL;
+
+out:
+	_tos->prof.pp = p;
+	p->count++;
+	switch(_tos->prof.what){
+	case Profkernel:
+		p->time = p->time - _tos->pcycles;
+		goto proftime;
+	case Profuser:
+		/* Add kernel cycles on proc entry */
+		p->time = p->time + _tos->kcycles;
+		/* fall through */
+	case Proftime:	
+	proftime:		/* Subtract cycle counter on proc entry */
+		_cycles((uvlong*)&t);
+		p->time = p->time - t;
+		break;
+	case Profsample:
+		p->time = p->time - _tos->clock;
+		break;
+	}
+	return arg;		/* disgusting linkage */
+}
+
+ulong
+_profout(void)
+{
+	Plink *p;
+	ulong arg;
+	vlong t;
+
+	arg = _savearg();
+	p = _tos->prof.pp;
+	if (p == NULL || (_tos->prof.pid != 0 && _tos->pid != _tos->prof.pid))
+		return arg;	/* Not our process */
+	switch(_tos->prof.what){
+	case Profkernel:		/* Add proc cycles on proc entry */
+		p->time = p->time + _tos->pcycles;
+		goto proftime;
+	case Profuser:			/* Subtract kernel cycles on proc entry */
+		p->time = p->time - _tos->kcycles;
+		/* fall through */
+	case Proftime:	
+	proftime:				/* Add cycle counter on proc entry */
+		_cycles((uvlong*)&t);
+		p->time = p->time + t;
+		break;
+	case Profsample:
+		p->time = p->time + _tos->clock;
+		break;
+	}
+	_tos->prof.pp = p->old;
+	return arg;
+}
+
+/* stdio may not be ready for us yet */
+static void
+err(char *fmt, ...)
+{
+	int fd;
+	va_list arg;
+	char buf[128];
+
+	if((fd = open("/dev/cons", OWRITE)) == -1)
+		return;
+	va_start(arg, fmt);
+	/*
+	 * C99 now requires *snprintf to return the number of characters
+	 * that *would* have been emitted, had there been room for them,
+	 * or a negative value on an `encoding error'.  Arrgh!
+	 */
+	vsnprintf(buf, sizeof buf, fmt, arg);
+	va_end(arg);
+	write(fd, buf, strlen(buf));
+	close(fd);
+}
+
+void
+_profdump(void)
+{
+	int f;
+	long n;
+	Plink *p;
+	char *vp;
+	char filename[64];
+
+	if (_tos->prof.what == 0)
+		return;	/* No profiling */
+	if (_tos->prof.pid != 0 && _tos->pid != _tos->prof.pid)
+		return;	/* Not our process */
+	if(perr)
+		err("%lud Prof errors\n", perr);
+	_tos->prof.pp = NULL;
+	if (_tos->prof.pid)
+		snprintf(filename, sizeof filename - 1, "prof.%ld", _tos->prof.pid);
+	else
+		snprintf(filename, sizeof filename - 1, "prof.out");
+	f = creat(filename, 0666);
+	if(f < 0) {
+		err("%s: cannot create - %s\n", filename, strerror(errno));
+		return;
+	}
+	_tos->prof.pid = ~0;	/* make sure data gets dumped once */
+	switch(_tos->prof.what){
+	case Profkernel:
+		_cycles((uvlong*)&_tos->prof.first->time);
+		_tos->prof.first->time = _tos->prof.first->time + _tos->pcycles;
+		break;
+	case Profuser:
+		_cycles((uvlong*)&_tos->prof.first->time);
+		_tos->prof.first->time = _tos->prof.first->time - _tos->kcycles;
+		break;
+	case Proftime:
+		_cycles((uvlong*)&_tos->prof.first->time);
+		break;
+	case Profsample:
+		_tos->prof.first->time = _tos->clock;
+		break;
+	}
+	vp = (char*)_tos->prof.first;
+
+	for(p = _tos->prof.first; p <= _tos->prof.next; p++) {
+
+		/*
+		 * short down
+		 */
+		n = 0xffff;
+		if(p->down)
+			n = p->down - _tos->prof.first;
+		vp[0] = n>>8;
+		vp[1] = n;
+
+		/*
+		 * short right
+		 */
+		n = 0xffff;
+		if(p->link)
+			n = p->link - _tos->prof.first;
+		vp[2] = n>>8;
+		vp[3] = n;
+		vp += 4;
+
+		/*
+		 * long pc
+		 */
+		n = p->pc;
+		vp[0] = n>>24;
+		vp[1] = n>>16;
+		vp[2] = n>>8;
+		vp[3] = n;
+		vp += 4;
+
+		/*
+		 * long count
+		 */
+		n = p->count;
+		vp[0] = n>>24;
+		vp[1] = n>>16;
+		vp[2] = n>>8;
+		vp[3] = n;
+		vp += 4;
+
+		/*
+		 * vlong time
+		 */
+		if (havecycles){
+			n = (vlong)(p->time / (vlong)khz);
+		}else
+			n = p->time;
+
+		vp[0] = n>>24;
+		vp[1] = n>>16;
+		vp[2] = n>>8;
+		vp[3] = n;
+		vp += 4;
+	}
+	write(f, (char*)_tos->prof.first, vp - (char*)_tos->prof.first);
+	close(f);
+
+}
+
+void
+_profinit(int entries, int what)
+{
+	if (_tos->prof.what == 0)
+		return;	/* Profiling not linked in */
+	_tos->prof.pp = NULL;
+	_tos->prof.first = calloc(entries*sizeof(Plink),1);
+	_tos->prof.last = _tos->prof.first + entries;
+	_tos->prof.next = _tos->prof.first;
+	_tos->prof.pid = _tos->pid;
+	_tos->prof.what = what;
+	_tos->clock = 1;
+}
+
+void
+_profmain(void)
+{
+	char ename[50];
+	int n, f;
+
+	n = 2000;
+	if (_tos->cyclefreq != 0LL){
+		khz = _tos->cyclefreq / 1000;	/* Report times in milliseconds */
+		havecycles = 1;
+	}
+	f = open("/env/profsize", OREAD);
+	if(f >= 0) {
+		memset(ename, 0, sizeof(ename));
+		read(f, ename, sizeof(ename)-1);
+		close(f);
+		n = atol(ename);
+	}
+	_tos->prof.what = Profuser;
+	f = open("/env/proftype", OREAD);
+	if(f >= 0) {
+		memset(ename, 0, sizeof(ename));
+		read(f, ename, sizeof(ename)-1);
+		close(f);
+		if (strcmp(ename, "user") == 0)
+			_tos->prof.what = Profuser;
+		else if (strcmp(ename, "kernel") == 0)
+			_tos->prof.what = Profkernel;
+		else if (strcmp(ename, "elapsed") == 0 || strcmp(ename, "time") == 0)
+			_tos->prof.what = Proftime;
+		else if (strcmp(ename, "sample") == 0)
+			_tos->prof.what = Profsample;
+	}
+	_tos->prof.first = sbrk(n*sizeof(Plink));
+	_tos->prof.last = sbrk(0);
+	_tos->prof.next = _tos->prof.first;
+	_tos->prof.pp = NULL;
+	_tos->prof.pid = _tos->pid;
+	atexit(_profdump);
+	_tos->clock = 1;
+}
+
+void prof(void (*fn)(void*), void *arg, int entries, int what)
+{
+	_profinit(entries, what);
+	_tos->prof.pp = _tos->prof.next;
+	fn(arg);
+	_profdump();
+}
+
+#pragma profile on
+
diff --git a/sys/src/ape/lib/ap/plan9/qlock.c b/sys/src/ape/lib/ap/plan9/qlock.c
new file mode 100755
index 000000000..b0882f789
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/qlock.c
@@ -0,0 +1,365 @@
+#define _LOCK_EXTENSION
+#define _QLOCK_EXTENSION
+#define _RESEARCH_SOURCE
+#include <u.h>
+#include <lock.h>
+#include <qlock.h>
+#include <stdlib.h>
+#include "sys9.h"
+
+#define rendezvous _RENDEZVOUS
+#define _rendezvousp rendezvous
+#define _tas tas
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+
+static struct {
+	QLp	*p;
+	QLp	x[1024];
+} ql = {
+	ql.x
+};
+
+enum
+{
+	Queuing,
+	QueuingR,
+	QueuingW,
+	Sleeping,
+};
+
+/* find a free shared memory location to queue ourselves in */
+static QLp*
+getqlp(void)
+{
+	QLp *p, *op;
+
+	op = ql.p;
+	for(p = op+1; ; p++){
+		if(p == &ql.x[nelem(ql.x)])
+			p = ql.x;
+		if(p == op)
+			abort();
+		if(_tas(&(p->inuse)) == 0){
+			ql.p = p;
+			p->next = nil;
+			break;
+		}
+	}
+	return p;
+}
+
+void
+qlock(QLock *q)
+{
+	QLp *p, *mp;
+
+	lock(&q->lock);
+	if(!q->locked){
+		q->locked = 1;
+		unlock(&q->lock);
+		return;
+	}
+
+
+	/* chain into waiting list */
+	mp = getqlp();
+	p = q->tail;
+	if(p == nil)
+		q->head = mp;
+	else
+		p->next = mp;
+	q->tail = mp;
+	mp->state = Queuing;
+	unlock(&q->lock);
+
+	/* wait */
+	while((*_rendezvousp)((ulong)mp, 1) == ~0)
+		;
+	mp->inuse = 0;
+}
+
+void
+qunlock(QLock *q)
+{
+	QLp *p;
+
+	lock(&q->lock);
+	p = q->head;
+	if(p != nil){
+		/* wakeup head waiting process */
+		q->head = p->next;
+		if(q->head == nil)
+			q->tail = nil;
+		unlock(&q->lock);
+		while((*_rendezvousp)((ulong)p, 0x12345) == ~0)
+			;
+		return;
+	}
+	q->locked = 0;
+	unlock(&q->lock);
+}
+
+int
+canqlock(QLock *q)
+{
+	if(!canlock(&q->lock))
+		return 0;
+	if(!q->locked){
+		q->locked = 1;
+		unlock(&q->lock);
+		return 1;
+	}
+	unlock(&q->lock);
+	return 0;
+}
+
+#if 0
+
+void
+rlock(RWLock *q)
+{
+	QLp *p, *mp;
+
+	lock(&q->lock);
+	if(q->writer == 0 && q->head == nil){
+		/* no writer, go for it */
+		q->readers++;
+		unlock(&q->lock);
+		return;
+	}
+
+	mp = getqlp();
+	p = q->tail;
+	if(p == 0)
+		q->head = mp;
+	else
+		p->next = mp;
+	q->tail = mp;
+	mp->next = nil;
+	mp->state = QueuingR;
+	unlock(&q->lock);
+
+	/* wait in kernel */
+	while((*_rendezvousp)((ulong)mp, 1) == ~0)
+		;
+	mp->inuse = 0;
+}
+
+int
+canrlock(RWLock *q)
+{
+	lock(&q->lock);
+	if (q->writer == 0 && q->head == nil) {
+		/* no writer; go for it */
+		q->readers++;
+		unlock(&q->lock);
+		return 1;
+	}
+	unlock(&q->lock);
+	return 0;
+}
+
+void
+runlock(RWLock *q)
+{
+	QLp *p;
+
+	lock(&q->lock);
+	if(q->readers <= 0)
+		abort();
+	p = q->head;
+	if(--(q->readers) > 0 || p == nil){
+		unlock(&q->lock);
+		return;
+	}
+
+	/* start waiting writer */
+	if(p->state != QueuingW)
+		abort();
+	q->head = p->next;
+	if(q->head == 0)
+		q->tail = 0;
+	q->writer = 1;
+	unlock(&q->lock);
+
+	/* wakeup waiter */
+	while((*_rendezvousp)((ulong)p, 0) == ~0)
+		;
+}
+
+void
+wlock(RWLock *q)
+{
+	QLp *p, *mp;
+
+	lock(&q->lock);
+	if(q->readers == 0 && q->writer == 0){
+		/* noone waiting, go for it */
+		q->writer = 1;
+		unlock(&q->lock);
+		return;
+	}
+
+	/* wait */
+	p = q->tail;
+	mp = getqlp();
+	if(p == nil)
+		q->head = mp;
+	else
+		p->next = mp;
+	q->tail = mp;
+	mp->next = nil;
+	mp->state = QueuingW;
+	unlock(&q->lock);
+
+	/* wait in kernel */
+	while((*_rendezvousp)((ulong)mp, 1) == ~0)
+		;
+	mp->inuse = 0;
+}
+
+int
+canwlock(RWLock *q)
+{
+	lock(&q->lock);
+	if (q->readers == 0 && q->writer == 0) {
+		/* no one waiting; go for it */
+		q->writer = 1;
+		unlock(&q->lock);
+		return 1;
+	}
+	unlock(&q->lock);
+	return 0;
+}
+
+void
+wunlock(RWLock *q)
+{
+	QLp *p;
+
+	lock(&q->lock);
+	if(q->writer == 0)
+		abort();
+	p = q->head;
+	if(p == nil){
+		q->writer = 0;
+		unlock(&q->lock);
+		return;
+	}
+	if(p->state == QueuingW){
+		/* start waiting writer */
+		q->head = p->next;
+		if(q->head == nil)
+			q->tail = nil;
+		unlock(&q->lock);
+		while((*_rendezvousp)((ulong)p, 0) == ~0)
+			;
+		return;
+	}
+
+	if(p->state != QueuingR)
+		abort();
+
+	/* wake waiting readers */
+	while(q->head != nil && q->head->state == QueuingR){
+		p = q->head;
+		q->head = p->next;
+		q->readers++;
+		while((*_rendezvousp)((ulong)p, 0) == ~0)
+			;
+	}
+	if(q->head == nil)
+		q->tail = nil;
+	q->writer = 0;
+	unlock(&q->lock);
+}
+
+void
+rsleep(Rendez *r)
+{
+	QLp *t, *me;
+
+	if(!r->l)
+		abort();
+	lock(&r->l->lock);
+	/* we should hold the qlock */
+	if(!r->l->locked)
+		abort();
+
+	/* add ourselves to the wait list */
+	me = getqlp();
+	me->state = Sleeping;
+	if(r->head == nil)
+		r->head = me;
+	else
+		r->tail->next = me;
+	me->next = nil;
+	r->tail = me;
+
+	/* pass the qlock to the next guy */
+	t = r->l->head;
+	if(t){
+		r->l->head = t->next;
+		if(r->l->head == nil)
+			r->l->tail = nil;
+		unlock(&r->l->lock);
+		while((*_rendezvousp)((ulong)t, 0x12345) == ~0)
+			;
+	}else{
+		r->l->locked = 0;
+		unlock(&r->l->lock);
+	}
+
+	/* wait for a wakeup */
+	while((*_rendezvousp)((ulong)me, 1) == ~0)
+		;
+	me->inuse = 0;
+}
+
+int
+rwakeup(Rendez *r)
+{
+	QLp *t;
+
+	/*
+	 * take off wait and put on front of queue
+	 * put on front so guys that have been waiting will not get starved
+	 */
+	
+	if(!r->l)
+		abort();
+	lock(&r->l->lock);
+	if(!r->l->locked)
+		abort();
+
+	t = r->head;
+	if(t == nil){
+		unlock(&r->l->lock);
+		return 0;
+	}
+
+	r->head = t->next;
+	if(r->head == nil)
+		r->tail = nil;
+
+	t->next = r->l->head;
+	r->l->head = t;
+	if(r->l->tail == nil)
+		r->l->tail = t;
+
+	t->state = Queuing;
+	unlock(&r->l->lock);
+	return 1;
+}
+
+int
+rwakeupall(Rendez *r)
+{
+	int i;
+
+	for(i=0; rwakeup(r); i++)
+		;
+	return i;
+}
+
+#endif
diff --git a/sys/src/ape/lib/ap/plan9/read.c b/sys/src/ape/lib/ap/plan9/read.c
new file mode 100755
index 000000000..471ab7e33
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/read.c
@@ -0,0 +1,46 @@
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include "lib.h"
+#include "sys9.h"
+
+#include <stdio.h>
+
+ssize_t
+read(int d, void *buf, size_t nbytes)
+{
+	int n, noblock, isbuf;
+	Fdinfo *f;
+
+	if(d<0 || d>=OPEN_MAX || !((f = &_fdinfo[d])->flags&FD_ISOPEN)){
+		errno = EBADF;
+		return -1;
+	}
+	if(nbytes <= 0)
+		return 0;
+	if(buf == 0){
+		errno = EFAULT;
+		return -1;
+	}
+	f = &_fdinfo[d];
+	noblock = f->oflags&O_NONBLOCK;
+	isbuf = f->flags&(FD_BUFFERED|FD_BUFFEREDX);
+	if(noblock || isbuf){
+		if(f->flags&FD_BUFFEREDX) {
+			errno = EIO;
+			return -1;
+		}
+		if(!isbuf) {
+			if(_startbuf(d) != 0) {
+				errno = EIO;
+				return -1;
+			}
+		}
+		n = _readbuf(d, buf, nbytes, noblock);
+	}else{
+		n = _READ(d,  buf, nbytes);
+		if(n < 0)
+			_syserrno();
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/rename.c b/sys/src/ape/lib/ap/plan9/rename.c
new file mode 100755
index 000000000..dddfea328
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/rename.c
@@ -0,0 +1,76 @@
+#include "lib.h"
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+rename(const char *from, const char *to)
+{
+	int n, i;
+	char *f, *t;
+	Dir *d, nd;
+	long mode;
+
+	if(access(to, 0) >= 0){
+		if(_REMOVE(to) < 0){
+			_syserrno();
+			return -1;
+		}
+	}
+	if((d = _dirstat(to)) != nil){
+		free(d);
+		errno = EEXIST;
+		return -1;
+	}
+	if((d = _dirstat(from)) == nil){
+		_syserrno();
+		return -1;
+	}
+	f = strrchr(from, '/');
+	t = strrchr(to, '/');
+	f = f? f+1 : from;
+	t = t? t+1 : to;
+	n = 0;
+	if(f-from==t-to && strncmp(from, to, f-from)==0){
+		/* from and to are in same directory (we miss some cases) */
+		i = strlen(t);
+		_nulldir(&nd);
+		nd.name = t;
+		if(_dirwstat(from, &nd) < 0){
+			_syserrno();
+			n = -1;
+		}
+	}else{
+		/* different directories: have to copy */
+		int ffd, tfd;
+		char buf[8192];
+
+		if((ffd = _OPEN(from, 0)) < 0 ||
+		   (tfd = _CREATE(to, 1, d->mode)) < 0){
+			_CLOSE(ffd);
+			_syserrno();
+			n = -1;
+		}
+		while(n>=0 && (n = _READ(ffd, buf, 8192)) > 0)
+			if(_WRITE(tfd, buf, n) != n){
+				_syserrno();
+				n = -1;
+			}
+		_CLOSE(ffd);
+		_CLOSE(tfd);
+		if(n>0)
+			n = 0;
+		if(n == 0) {
+			if(_REMOVE(from) < 0){
+				_syserrno();
+				return -1;
+			}
+		}
+	}
+	free(d);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/rmdir.c b/sys/src/ape/lib/ap/plan9/rmdir.c
new file mode 100755
index 000000000..a799bc00b
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/rmdir.c
@@ -0,0 +1,17 @@
+#include "lib.h"
+#include <errno.h>
+#include <unistd.h>
+#include "sys9.h"
+
+int
+rmdir(const char *path)
+{
+	int n;
+
+	n = 0;
+	if(_REMOVE(path) < 0) {
+		_syserrno();
+		n = -1;
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/setgid.c b/sys/src/ape/lib/ap/plan9/setgid.c
new file mode 100755
index 000000000..7c9075c3f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/setgid.c
@@ -0,0 +1,14 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+/*
+ * BUG: never works
+ */
+
+int
+setgid(gid_t gid)
+{
+	errno = EPERM;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/setpgid.c b/sys/src/ape/lib/ap/plan9/setpgid.c
new file mode 100755
index 000000000..dd5445085
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/setpgid.c
@@ -0,0 +1,31 @@
+#include "lib.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include "sys9.h"
+
+int
+setpgid(pid_t pid, pid_t pgid)
+{
+	int n, f;
+	char buf[50], fname[30];
+
+	if(pid == 0)
+		pid = getpid();
+	if(pgid == 0)
+		pgid = getpgrp();
+	sprintf(fname, "/proc/%d/noteid", pid);
+	f = open(fname, 1);
+	if(f < 0) {
+		errno = ESRCH;
+		return -1;
+	}
+	n = sprintf(buf, "%d", pgid);
+	n = write(f, buf, n);
+	if(n < 0)
+		_syserrno();
+	else
+		n = 0;
+	close(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/setsid.c b/sys/src/ape/lib/ap/plan9/setsid.c
new file mode 100755
index 000000000..f53f8f2f3
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/setsid.c
@@ -0,0 +1,14 @@
+#include "lib.h"
+#include <unistd.h>
+#include "sys9.h"
+
+pid_t
+setsid(void)
+{
+	if(_RFORK(RFNAMEG|RFNOTEG) < 0){
+		_syserrno();
+		return -1;
+	}
+	_sessleader = 1;
+	return getpgrp();
+}
diff --git a/sys/src/ape/lib/ap/plan9/setuid.c b/sys/src/ape/lib/ap/plan9/setuid.c
new file mode 100755
index 000000000..a34f2de6f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/setuid.c
@@ -0,0 +1,14 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+/*
+ * BUG: never works
+ */
+
+int
+setuid(uid_t uid)
+{
+	errno = EPERM;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/signal.c b/sys/src/ape/lib/ap/plan9/signal.c
new file mode 100755
index 000000000..cf8a823ef
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/signal.c
@@ -0,0 +1,136 @@
+#include "lib.h"
+#include "sys9.h"
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <setjmp.h>
+
+extern sigset_t	_psigblocked;
+
+static struct {
+	char	*msg;	/* just check prefix */
+	int	num;
+} sigtab[] = {
+	{"hangup",				SIGHUP},
+	{"interrupt",				SIGINT},
+	{"quit",				SIGQUIT},
+	{"alarm",				SIGALRM},
+	{"sys: trap: illegal instruction",	SIGILL},
+	{"sys: trap: reserved instruction",	SIGILL},
+	{"sys: trap: reserved",			SIGILL},
+	{"sys: trap: arithmetic overflow",	SIGFPE},
+	{"abort",				SIGABRT},
+	{"sys: fp:",				SIGFPE},
+	{"exit",				SIGKILL},
+	{"die",					SIGKILL},
+	{"kill",				SIGKILL},
+	{"sys: trap: bus error",		SIGSEGV},
+	{"sys: trap: address error",		SIGSEGV},
+	{"sys: trap: TLB",			SIGSEGV},
+	{"sys: write on closed pipe",		SIGPIPE},
+	{"alarm",				SIGALRM},
+	{"term",				SIGTERM},
+	{"usr1",				SIGUSR1},
+	{"usr2",				SIGUSR2},
+};
+#define NSIGTAB ((sizeof sigtab)/(sizeof (sigtab[0])))
+
+void	(*_sighdlr[MAXSIG+1])(int, char*, Ureg*); /* 0 initialized: SIG_DFL */
+
+void
+(*signal(int sig, void (*func)(int, char*, Ureg*)))(int, char*, Ureg*)
+{
+	void(*oldf)(int, char*, Ureg*);
+
+	if(sig <= 0 || sig > MAXSIG){
+		errno = EINVAL;
+		return SIG_ERR;
+	}
+	oldf = _sighdlr[sig];
+	if(sig == SIGKILL)
+		return oldf;	/* can't catch or ignore SIGKILL */
+	_sighdlr[sig] = func;
+	return oldf;
+}
+
+/* BAD CODE - see /sys/src/ape/lib/ap/$objtype/setjmp.s for real code
+int
+sigsetjmp(sigjmp_buf buf, int savemask)
+{
+	int r;
+
+	buf[0] = savemask;
+	buf[1] = _psigblocked;
+	return setjmp(&buf[2]);
+}
+*/
+
+/*
+ * BUG: improper handling of process signal mask
+ */
+int
+sigaction(int sig, struct sigaction *act, struct sigaction *oact)
+{
+	if(sig <= 0 || sig > MAXSIG || sig == SIGKILL){
+		errno = EINVAL;
+		return -1;
+	}
+	if(oact){
+		oact->sa_handler = _sighdlr[sig];
+		oact->sa_mask = _psigblocked;
+		oact->sa_flags = 0;
+	}
+	if(act){
+		_sighdlr[sig] = act->sa_handler;
+	}
+	return 0;
+}
+
+/* this is registered in _envsetup */
+int
+_notehandler(Ureg *u, char *msg)
+{
+	int i;
+	void(*f)(int, char*, Ureg*);
+	extern void _doatexits(void);	/* in stdio/exit.c */
+
+	if(_finishing)
+		_finish(0, 0);
+	for(i = 0; i<NSIGTAB; i++){
+		if(strncmp(msg, sigtab[i].msg, strlen(sigtab[i].msg)) == 0){
+			f = _sighdlr[sigtab[i].num];
+			if(f == SIG_DFL || f == SIG_ERR)
+				break;
+			if(f != SIG_IGN) {
+				_notetramp(sigtab[i].num, f, u);
+				/* notetramp is machine-dependent; doesn't return to here */
+			}
+			_NOTED(0); /* NCONT */
+			return;
+		}
+	}
+	_doatexits();
+	_NOTED(1); /* NDFLT */
+}
+
+int
+_stringsig(char *nam)
+{
+	int i;
+
+	for(i = 0; i<NSIGTAB; i++)
+		if(strncmp(nam, sigtab[i].msg, strlen(sigtab[i].msg)) == 0)
+			return sigtab[i].num;
+	return 0;
+}
+
+char *
+_sigstring(int sig)
+{
+	int i;
+
+	for(i=0; i<NSIGTAB; i++)
+		if(sigtab[i].num == sig)
+			return sigtab[i].msg;
+	return "unknown signal";
+}
diff --git a/sys/src/ape/lib/ap/plan9/sigpending.c b/sys/src/ape/lib/ap/plan9/sigpending.c
new file mode 100755
index 000000000..8b5eb2eda
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sigpending.c
@@ -0,0 +1,11 @@
+#include <signal.h>
+
+/*
+ * BUG: don't keep track of these
+ */
+int
+sigpending(sigset_t *set)
+{
+	*set = 0;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/sigprocmask.c b/sys/src/ape/lib/ap/plan9/sigprocmask.c
new file mode 100755
index 000000000..84b94f987
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sigprocmask.c
@@ -0,0 +1,23 @@
+#include "lib.h"
+#include <signal.h>
+#include <errno.h>
+
+sigset_t _psigblocked;
+
+int
+sigprocmask(int how, sigset_t *set, sigset_t *oset)
+{
+	if(oset)
+		*oset = _psigblocked;
+	if(how==SIG_BLOCK)
+		_psigblocked |= *set;
+	else if(how==SIG_UNBLOCK)
+		_psigblocked &= ~*set;
+	else if(how==SIG_SETMASK)
+		_psigblocked = *set;
+	else{
+		errno = EINVAL;
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/sigsuspend.c b/sys/src/ape/lib/ap/plan9/sigsuspend.c
new file mode 100755
index 000000000..290c15d0f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sigsuspend.c
@@ -0,0 +1,13 @@
+#include <signal.h>
+#include <errno.h>
+
+/*
+ * BUG: doesn't work
+ */
+
+int
+sigsuspend(sigset_t *set)
+{
+	errno = EINVAL;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/sleep.c b/sys/src/ape/lib/ap/plan9/sleep.c
new file mode 100755
index 000000000..a6fcf19a9
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sleep.c
@@ -0,0 +1,17 @@
+#include "lib.h"
+#include <unistd.h>
+#include <time.h>
+#include "sys9.h"
+
+unsigned int
+sleep(unsigned int secs)
+{
+	time_t t0, t1;
+
+	t0 = time(0);
+	if(_SLEEP(secs*1000) < 0){
+		t1 = time(0);
+		return t1-t0;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/sqrt.c b/sys/src/ape/lib/ap/plan9/sqrt.c
new file mode 100755
index 000000000..98974360d
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sqrt.c
@@ -0,0 +1,56 @@
+/*
+	sqrt returns the square root of its floating
+	point argument. Newton's method.
+
+	calls frexp
+*/
+
+#include <math.h>
+#include <errno.h>
+#define _RESEARCH_SOURCE
+#include <float.h>
+
+double
+sqrt(double arg)
+{
+	double x, temp;
+	int exp, i;
+
+	if(isInf(arg, 1))
+		return arg;
+	if(arg <= 0) {
+		if(arg < 0)
+			errno = EDOM;
+		return 0;
+	}
+	x = frexp(arg, &exp);
+	while(x < 0.5) {
+		x *= 2;
+		exp--;
+	}
+	/*
+	 * NOTE
+	 * this wont work on 1's comp
+	 */
+	if(exp & 1) {
+		x *= 2;
+		exp--;
+	}
+	temp = 0.5 * (1.0+x);
+
+	while(exp > 60) {
+		temp *= (1L<<30);
+		exp -= 60;
+	}
+	while(exp < -60) {
+		temp /= (1L<<30);
+		exp += 60;
+	}
+	if(exp >= 0)
+		temp *= 1L << (exp/2);
+	else
+		temp /= 1L << (-exp/2);
+	for(i=0; i<=4; i++)
+		temp = 0.5*(temp + arg/temp);
+	return temp;
+}
diff --git a/sys/src/ape/lib/ap/plan9/stat.c b/sys/src/ape/lib/ap/plan9/stat.c
new file mode 100755
index 000000000..be0d7c484
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/stat.c
@@ -0,0 +1,21 @@
+#include "lib.h"
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+stat(const char *path, struct stat *buf)
+{
+	Dir *d;
+
+	if((d = _dirstat(path)) == nil){
+		_syserrno();
+		return -1;
+	}
+	_dirtostat(buf, d, 0);
+	free(d);
+
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/sys9.h b/sys/src/ape/lib/ap/plan9/sys9.h
new file mode 100755
index 000000000..b289273cb
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/sys9.h
@@ -0,0 +1,121 @@
+typedef
+struct Waitmsg
+{
+	int pid;	/* of loved one */
+	unsigned long time[3];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+#define	STATMAX	65535U	/* max length of machine-independent stat structure */
+#define	DIRMAX	(sizeof(Dir)+STATMAX)	/* max length of Dir structure */
+#define	ERRMAX	128	/* max length of error string */
+
+#define	MORDER	0x0003	/* mask for bits defining order of mounting */
+#define	MREPL	0x0000	/* mount replaces object */
+#define	MBEFORE	0x0001	/* mount goes before others in union directory */
+#define	MAFTER	0x0002	/* mount goes after others in union directory */
+#define	MCREATE	0x0004	/* permit creation in mounted directory */
+#define	MCACHE	0x0010	/* cache some data */
+#define	MMASK	0x0007	/* all bits on */
+
+#define	OREAD	0	/* open for read */
+#define	OWRITE	1	/* write */
+#define	ORDWR	2	/* read and write */
+#define	OEXEC	3	/* execute, == read but check execute permission */
+#define	OTRUNC	16	/* or'ed in (except for exec), truncate file first */
+#define	OCEXEC	32	/* or'ed in, close on exec */
+#define	ORCLOSE	64	/* or'ed in, remove on close */
+#define	OEXCL	0x1000	/* or'ed in, exclusive use (create only) */
+
+#define	AEXIST	0	/* accessible: exists */
+#define	AEXEC	1	/* execute access */
+#define	AWRITE	2	/* write access */
+#define	AREAD	4	/* read access */
+
+/* Segattch */
+#define	SG_RONLY	0040	/* read only */
+#define	SG_CEXEC	0100	/* detach on exec */
+
+#define	NCONT	0	/* continue after note */
+#define	NDFLT	1	/* terminate after note */
+#define	NSAVE	2	/* clear note but hold state */
+#define	NRSTR	3	/* restore saved state */
+
+/* bits in Qid.type */
+#define QTDIR		0x80		/* type bit for directories */
+#define QTAPPEND	0x40		/* type bit for append only files */
+#define QTEXCL		0x20		/* type bit for exclusive use files */
+#define QTMOUNT		0x10		/* type bit for mounted channel */
+#define QTFILE		0x00		/* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR		0x80000000	/* mode bit for directories */
+#define DMAPPEND	0x40000000	/* mode bit for append only files */
+#define DMEXCL		0x20000000	/* mode bit for exclusive use files */
+#define DMMOUNT		0x10000000	/* mode bit for mounted channel */
+#define DMREAD		0x4		/* mode bit for read permission */
+#define DMWRITE		0x2		/* mode bit for write permission */
+#define DMEXEC		0x1		/* mode bit for execute permission */
+
+/* rfork */
+enum
+{
+	RFNAMEG		= (1<<0),
+	RFENVG		= (1<<1),
+	RFFDG		= (1<<2),
+	RFNOTEG		= (1<<3),
+	RFPROC		= (1<<4),
+	RFMEM		= (1<<5),
+	RFNOWAIT	= (1<<6),
+	RFCNAMEG	= (1<<10),
+	RFCENVG		= (1<<11),
+	RFCFDG		= (1<<12),
+	RFREND		= (1<<13),
+	RFNOMNT		= (1<<14)
+};
+
+extern	int	_AWAIT(char*, int);
+extern	int	_ALARM(unsigned long);
+extern	int	_BIND(const char*, const char*, int);
+extern	int	_CHDIR(const char*);
+extern	int	_CLOSE(int);
+extern	int	_CREATE(char*, int, unsigned long);
+extern	int	_DUP(int, int);
+extern	int	_ERRSTR(char*, unsigned int);
+extern	int	_EXEC(char*, char*[]);
+extern	void	_EXITS(char *);
+extern	int	_FD2PATH(int, char*, int);
+extern	int	_FAUTH(int, char*);
+extern	int	_FSESSION(int, char*, int);
+extern	int	_FSTAT(int, unsigned char*, int);
+extern	int	_FWSTAT(int, unsigned char*, int);
+extern	int	_MOUNT(int, int, const char*, int, const char*);
+extern	int	_NOTED(int);
+extern	int	_NOTIFY(int(*)(void*, char*));
+extern	int	_OPEN(const char*, int);
+extern	int	_PIPE(int*);
+extern	long	_PREAD(int, void*, long, long long);
+extern	long	_PWRITE(int, void*, long, long long);
+extern	long	_READ(int, void*, long);
+extern	int	_REMOVE(const char*);
+extern	int	_RENDEZVOUS(unsigned long, unsigned long);
+extern	int	_RFORK(int);
+extern	int	_SEGATTACH(int, char*, void*, unsigned long);
+extern	int	_SEGBRK(void*, void*);
+extern	int	_SEGDETACH(void*);
+extern	int	_SEGFLUSH(void*, unsigned long);
+extern	int	_SEGFREE(void*, unsigned long);
+extern	long long	_SEEK(int, long long, int);
+extern	int	_SLEEP(long);
+extern	int	_STAT(const char*, unsigned char*, int);
+extern	Waitmsg*	_WAIT(void);
+extern	long	_WRITE(int, const void*, long);
+extern	int	_WSTAT(const char*, unsigned char*, int);
+
+extern	int	__open(char *, int, ...);
+extern	int	__access(char *, int);
+extern	int	__chdir(char *);
+extern	int	__creat(char *, int);
+extern	int	__link(char *, int);
+extern	int	__stat(char *, struct stat *);
+extern	int	__unlink(char *);
diff --git a/sys/src/ape/lib/ap/plan9/system.c b/sys/src/ape/lib/ap/plan9/system.c
new file mode 100755
index 000000000..497b0e1f1
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/system.c
@@ -0,0 +1,40 @@
+#include "lib.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int
+system(const char *s)
+{
+	int w, status;
+	pid_t pid;
+	char cmd[30], *oty;
+
+	oty = getenv("cputype");
+	if(!oty)
+		return -1;
+	if(!s)
+		return 1; /* a command interpreter is available */
+	pid = fork();
+	snprintf(cmd, sizeof cmd, "/%s/bin/ape/sh", oty);
+	if(pid == 0) {
+		execl(cmd, "sh", "-c", s, NULL);
+		_exit(1);
+	}
+	if(pid < 0){
+		_syserrno();
+		return -1;
+	}
+	for(;;) {
+		w = wait(&status);
+		if(w == -1 || w == pid)
+			break;
+	}
+
+	if(w == -1){
+		_syserrno();
+		return w;
+	}
+	return status;
+}
diff --git a/sys/src/ape/lib/ap/plan9/tcgetattr.c b/sys/src/ape/lib/ap/plan9/tcgetattr.c
new file mode 100755
index 000000000..8a7d3e608
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/tcgetattr.c
@@ -0,0 +1,201 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <termios.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "sys9.h"
+#include "lib.h"
+#include "dir.h"
+
+#define	CESC	'\\'
+#define	CINTR	0177	/* DEL */
+#define	CQUIT	034	/* FS, cntl | */
+#define	CERASE	010	/* BS */
+#define	CKILL	025 /* cntl u */
+#define	CEOF	04	/* cntl d */
+#define	CSTART	021	/* cntl q */
+#define	CSTOP	023	/* cntl s */
+#define	CSWTCH	032	/* cntl z */
+#define CEOL	000
+#define	CNSWTCH	0
+
+static int
+isptty(int fd)
+{
+	Dir *d;
+	int rv;
+
+	if((d = _dirfstat(fd)) == nil)
+		return 0;
+	rv = (strncmp(d->name, "ptty", 4) == 0);
+	free(d);
+	return rv;
+}
+
+int
+tcgetattr(int fd, struct termios *t)
+{
+	int n;
+	char buf[60];
+
+	if(!isptty(fd)) {
+		if(isatty(fd)) {
+			/* If there is no emulation return sensible defaults */
+			t->c_iflag = ISTRIP|ICRNL|IXON|IXOFF;
+			t->c_oflag = OPOST|TAB3|ONLCR;
+			t->c_cflag = B9600;
+			t->c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK;
+			t->c_cc[VINTR] = CINTR;
+			t->c_cc[VQUIT] = CQUIT;
+			t->c_cc[VERASE] = CERASE;
+			t->c_cc[VKILL] = CKILL;
+			t->c_cc[VEOF] = CEOF;
+			t->c_cc[VEOL] = CEOL;
+			t->c_cc[VSTART] = CSTART;
+			t->c_cc[VSTOP] = CSTOP;
+			return 0;
+		} else {
+			errno = ENOTTY;
+			return -1;
+		}
+	}
+	if(_SEEK(fd, -2, 0) != -2) {
+		_syserrno();
+		return -1;
+	}
+
+	n = _READ(fd, buf, 57);
+	if(n < 0) {
+		_syserrno();
+		return -1;
+	}
+
+	t->c_iflag = strtoul(buf+4, 0, 16);
+	t->c_oflag = strtoul(buf+9, 0, 16);
+	t->c_cflag = strtoul(buf+14, 0, 16);
+	t->c_lflag = strtoul(buf+19, 0, 16);
+
+	for(n = 0; n < NCCS; n++)
+		t->c_cc[n] = strtoul(buf+24+(n*3), 0, 16);
+
+	return 0;
+}
+
+/* BUG: ignores optional actions */
+
+int
+tcsetattr(int fd, int optactions, const struct termios *t)
+{
+	int n, i;
+	char buf[100];
+
+	if(!isptty(fd)) {
+		if(!isatty(fd)) {
+			errno = ENOTTY;
+			return -1;
+		} else
+			return 0;
+	}
+	n = sprintf(buf, "IOW %4.4x %4.4x %4.4x %4.4x ",
+		t->c_iflag, t->c_oflag, t->c_cflag, t->c_lflag);
+
+	for(i = 0; i < NCCS; i++)
+		n += sprintf(buf+n, "%2.2x ", t->c_cc[i]);
+
+	if(_SEEK(fd, -2, 0) != -2) {
+		_syserrno();
+		return -1;
+	}
+
+	n = _WRITE(fd, buf, n);
+	if(n < 0) {
+		_syserrno();
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+tcsetpgrp(int fd, pid_t pgrpid)
+{
+	int n;
+	char buf[30];
+
+	if(!isptty(fd)) {
+		if(!isatty(fd)) {
+			errno = ENOTTY;
+			return -1;
+		} else
+			return 0;
+	}
+	n = sprintf(buf, "IOW note %d", pgrpid);
+
+	if(_SEEK(fd, -2, 0) != -2) {
+		_syserrno();
+		return -1;
+	}
+
+	n = _WRITE(fd, buf, n);
+	if(n < 0) {
+		_syserrno();
+		return -1;
+	}
+}
+
+pid_t
+tcgetpgrp(int fd)
+{
+	int n;
+	pid_t pgrp;
+	char buf[100];
+
+	if(!isptty(fd)) {
+		errno = ENOTTY;
+		return -1;
+	}
+	if(_SEEK(fd, -2, 0) != -2) {
+		_syserrno();
+		return -1;
+	}
+	n = _READ(fd, buf, sizeof(buf));
+	if(n < 0) {
+		_syserrno();
+		return -1;
+	}
+	pgrp = atoi(buf+24+(NCCS*3));
+	return pgrp;
+}
+
+/* should do a better job here */
+
+int
+tcdrain(int)
+{
+	errno = ENOTTY;
+	return -1;
+}
+
+int
+tcflush(int, int)
+{
+	errno = ENOTTY;
+	return -1;
+}
+
+int
+tcflow(int, int)
+{
+	errno = ENOTTY;
+	return -1;
+}
+
+int
+tcsendbreak(int)
+{
+	errno = ENOTTY;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/plan9/time.c b/sys/src/ape/lib/ap/plan9/time.c
new file mode 100755
index 000000000..85a1e72b2
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/time.c
@@ -0,0 +1,27 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+
+time_t
+time(time_t *tp)
+{
+	char b[20];
+	int f;
+	time_t t;
+
+	memset(b, 0, sizeof(b));
+	f = _OPEN("/dev/time", 0);
+	if(f >= 0) {
+		_PREAD(f, b, sizeof(b), 0);
+		_CLOSE(f);
+	}
+	t = atol(b);
+	if(tp)
+		*tp = t;
+	return t;
+}
diff --git a/sys/src/ape/lib/ap/plan9/times.c b/sys/src/ape/lib/ap/plan9/times.c
new file mode 100755
index 000000000..2d1e95c8c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/times.c
@@ -0,0 +1,51 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/times.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+static
+char*
+skip(char *p)
+{
+
+	while(*p == ' ')
+		p++;
+	while(*p != ' ' && *p != 0)
+		p++;
+	return p;
+}
+
+clock_t
+times(struct tms *buf)
+{
+	char b[200], *p;
+	int f;
+	unsigned long r;
+
+	memset(b, 0, sizeof(b));
+	f = open("/dev/cputime", O_RDONLY);
+	if(f >= 0) {
+		lseek(f, SEEK_SET, 0);
+		read(f, b, sizeof(b));
+		close(f);
+	}
+	p = b;
+	if(buf)
+		buf->tms_utime = atol(p);
+	p = skip(p);
+	if(buf)
+		buf->tms_stime = atol(p);
+	p = skip(p);
+	r = atol(p);
+	if(buf){
+		p = skip(p);
+		buf->tms_cutime = atol(p);
+		p = skip(p);
+		buf->tms_cstime = atol(p);
+	}
+	return r;
+}
diff --git a/sys/src/ape/lib/ap/plan9/tmpfile.c b/sys/src/ape/lib/ap/plan9/tmpfile.c
new file mode 100755
index 000000000..c3ab5fd88
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/tmpfile.c
@@ -0,0 +1,44 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include "sys9.h"
+#undef OPEN
+#include "../stdio/iolib.h"
+#include "lib.h"
+#include "dir.h"
+
+FILE *
+tmpfile(void){
+	FILE *f;
+	static char name[]="/tmp/tf0000000000000";
+	char *p;
+	int n;
+	for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++)
+		if(f->state==CLOSED)
+			break;
+	if(f==&_IO_stream[FOPEN_MAX])
+		return NULL;
+	while(access(name, 0) >= 0){
+		p = name+7;
+		while(*p == '9')
+			*p++ = '0';
+		if(*p == '\0')
+			return NULL;
+		++*p;
+	}
+	n = _CREATE(name, 64|2, 0777); /* remove-on-close */
+	if(n==-1){
+		_syserrno();
+		return NULL;
+	}
+	_fdinfo[n].flags = FD_ISOPEN;
+	_fdinfo[n].oflags = 2;
+	f->fd=n;
+	f->flags=0;
+	f->state=OPEN;
+	f->buf=0;
+	f->rp=0;
+	f->wp=0;
+	f->lp=0;
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/plan9/ttyname.c b/sys/src/ape/lib/ap/plan9/ttyname.c
new file mode 100755
index 000000000..980186a81
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/ttyname.c
@@ -0,0 +1,11 @@
+#include <unistd.h>
+#include <stdio.h>
+
+char *
+ttyname(int fd)
+{
+	static char buf[100];
+
+	sprintf(buf, "/fd/%d", fd);
+	return buf;
+}
diff --git a/sys/src/ape/lib/ap/plan9/umask.c b/sys/src/ape/lib/ap/plan9/umask.c
new file mode 100755
index 000000000..b45b7576c
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/umask.c
@@ -0,0 +1,13 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+/*
+ * No such concept in plan9, but supposed to be always successful
+ */
+
+mode_t
+umask(mode_t numask)
+{
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/uname.c b/sys/src/ape/lib/ap/plan9/uname.c
new file mode 100755
index 000000000..1df2a941f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/uname.c
@@ -0,0 +1,25 @@
+#include <stdlib.h>
+#include <string.h>
+#include <sys/utsname.h>
+
+int
+uname(struct utsname *n)
+{
+	n->sysname = getenv("osname");
+	if(!n->sysname)
+		n->sysname = "Plan9";
+	n->nodename = getenv("sysname");
+	if(!n->nodename){
+		n->nodename = getenv("site");
+		if(!n->nodename)
+			n->nodename = "?";
+	}
+	n->release = "4";			/* edition */
+	n->version = "0";
+	n->machine = getenv("cputype");
+	if(!n->machine)
+		n->machine = "?";
+	if(strcmp(n->machine, "386") == 0)
+		n->machine = "i386";		/* for gnu configure */
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/plan9/unlink.c b/sys/src/ape/lib/ap/plan9/unlink.c
new file mode 100755
index 000000000..a015c782f
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/unlink.c
@@ -0,0 +1,75 @@
+#include "lib.h"
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+
+/*
+ * BUG: errno mapping
+ */
+
+int
+unlink(const char *path)
+{
+	int n, i, fd;
+	long long nn;
+	Dir *db1, *db2, nd;
+	Fdinfo *f;
+ 	char *p, newname[PATH_MAX], newelem[32];
+
+	/* if the file is already open, make it close-on-exec (and rename to qid) */
+	if((db1 = _dirstat(path)) == nil) {
+		_syserrno();
+		return -1;
+	}
+	fd = -1;
+	for(i=0, f = _fdinfo;i < OPEN_MAX; i++, f++) {
+		if((f->flags&FD_ISOPEN) && (db2=_dirfstat(i)) != nil) {
+			if(db1->qid.path == db2->qid.path &&
+			   db1->qid.vers == db2->qid.vers &&
+			   db1->type == db2->type &&
+			   db1->dev == db2->dev) {
+				sprintf(newelem, "%8.8lx%8.8lx", (ulong)(db2->qid.path>>32), (ulong)db2->qid.path);
+				_nulldir(&nd);
+				nd.name = newelem;
+				if(_dirfwstat(i, &nd) < 0)
+					p = (char*)path;
+				else {
+					p = strrchr(path, '/');
+					if(p == 0)
+						p = newelem; 
+					else {
+						memmove(newname, path, p-path);
+						newname[p-path] = '/';
+						strcpy(newname+(p-path)+1, newelem);
+						p = newname;
+					}
+				}
+				/* reopen remove on close */
+				fd = _OPEN(p, 64|(f->oflags)); 
+				if(fd < 0){
+					free(db2);
+					continue;
+				}
+				nn = _SEEK(i, 0, 1);
+				if(nn < 0)
+					nn = 0;
+				_SEEK(fd, nn, 0);
+				_DUP(fd, i);
+				_CLOSE(fd);
+				free(db1);
+				return 0;
+			}
+			free(db2);
+		}
+	}
+	if(fd == -1)
+		if((n=_REMOVE(path)) < 0)
+			_syserrno();
+	free(db1);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/utime.c b/sys/src/ape/lib/ap/plan9/utime.c
new file mode 100755
index 000000000..52eeb34e2
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/utime.c
@@ -0,0 +1,30 @@
+#include "lib.h"
+#include <sys/types.h>
+#include <time.h>
+#include <utime.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "sys9.h"
+#include "dir.h"
+
+int
+utime(const char *path, const struct utimbuf *times)
+{
+	int n;
+	Dir nd;
+	time_t curt;
+
+	_nulldir(&nd);
+	if(times == 0) {
+		curt = time(0);
+		nd.atime = curt;
+		nd.mtime = curt;
+	} else {
+		nd.atime = times->actime;
+		nd.mtime = times->modtime;
+	}
+	n = _dirwstat(path, &nd);
+	if(n < 0)
+		_syserrno();
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/plan9/wait.c b/sys/src/ape/lib/ap/plan9/wait.c
new file mode 100755
index 000000000..ac1ab13da
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/wait.c
@@ -0,0 +1,150 @@
+#include "lib.h"
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include "sys9.h"
+#include "dir.h"
+
+/*
+ * status not yet collected for processes that have exited
+ */
+typedef struct Waited Waited;
+struct Waited {
+	Waitmsg*	msg;
+	Waited*	next;
+};
+static Waited *wd;
+
+static Waitmsg *
+lookpid(int pid)
+{
+	Waited **wl, *w;
+	Waitmsg *msg;
+
+	for(wl = &wd; (w = *wl) != nil; wl = &w->next)
+		if(pid <= 0 || w->msg->pid == pid){
+			msg = w->msg;
+			*wl = w->next;
+			free(w);
+			return msg;
+		}
+	return 0;
+}
+
+static void
+addpid(Waitmsg *msg)
+{
+	Waited *w;
+
+	w = malloc(sizeof(*w));
+	if(w == nil){
+		/* lost it; what can we do? */
+		free(msg);
+		return;
+	}
+	w->msg = msg;
+	w->next = wd;
+	wd = w;
+}
+
+static int
+waitstatus(Waitmsg *w)
+{
+	int r, t;
+	char *bp, *ep;
+
+	r = 0;
+	t = 0;
+	if(w->msg[0]){
+		/* message is 'prog pid:string' */
+		bp = w->msg;
+		while(*bp){
+			if(*bp++ == ':')
+				break;
+		}
+		if(*bp == 0)
+			bp = w->msg;
+		r = strtol(bp, &ep, 10);
+		if(*ep == 0){
+			if(r < 0 || r >= 256)
+				r = 1;
+		}else{
+			t = _stringsig(bp);
+			if(t == 0)
+				r = 1;
+		}
+	}
+	return (r<<8) | t;
+}
+
+static void
+waitresource(struct rusage *ru, Waitmsg *w)
+{
+	memset(ru, 0, sizeof(*ru));
+	ru->ru_utime.tv_sec = w->time[0]/1000;
+	ru->ru_utime.tv_usec = (w->time[0]%1000)*1000;
+	ru->ru_stime.tv_sec = w->time[1]/1000;
+	ru->ru_stime.tv_usec = (w->time[1]%1000)*1000;
+}
+
+pid_t
+wait(int *status)
+{
+	return wait4(-1, status, 0, nil);
+}
+
+pid_t
+waitpid(pid_t wpid, int *status, int options)
+{
+	return wait4(wpid, status, options, nil);
+}
+
+pid_t
+wait3(int *status, int options, struct rusage *res)
+{
+	return wait4(-1, status, options, res);
+}
+
+pid_t
+wait4(pid_t wpid, int *status, int options, struct rusage *res)
+{
+	char pname[50];
+	Dir *d;
+	Waitmsg *w;
+
+	w = lookpid(wpid);
+	if(w == nil){
+		if(options & WNOHANG){
+			snprintf(pname, sizeof(pname), "/proc/%d/wait", getpid());
+			d = _dirstat(pname);
+			if(d != nil && d->length == 0){
+				free(d);
+				return 0;
+			}
+			free(d);
+		}
+		for(;;){
+			w = _WAIT();
+			if(w == nil){
+				_syserrno();
+				return -1;
+			}
+			if(wpid <= 0 || w->pid == wpid)
+				break;
+			addpid(w);
+		}
+	}
+	if(res != nil)
+		waitresource(res, w);
+	if(status != nil)
+		*status = waitstatus(w);
+	wpid = w->pid;
+	free(w);
+	return wpid;
+}
diff --git a/sys/src/ape/lib/ap/plan9/write.c b/sys/src/ape/lib/ap/plan9/write.c
new file mode 100755
index 000000000..6795bbc92
--- /dev/null
+++ b/sys/src/ape/lib/ap/plan9/write.c
@@ -0,0 +1,21 @@
+#include <errno.h>
+#include <unistd.h>
+#include "lib.h"
+#include "sys9.h"
+
+ssize_t
+write(int d, const void *buf, size_t nbytes)
+{
+	int n;
+
+	if(d<0 || d>=OPEN_MAX || !(_fdinfo[d].flags&FD_ISOPEN)){
+		errno = EBADF;
+		return -1;
+	}
+	if(_fdinfo[d].oflags&O_APPEND)
+		_SEEK(d, 0, 2);
+	n = _WRITE(d, buf, nbytes);
+	if(n < 0)
+		_syserrno();
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/posix/getgrent.c b/sys/src/ape/lib/ap/posix/getgrent.c
new file mode 100755
index 000000000..345ec2ed5
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/getgrent.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <grp.h>
+#include <stdlib.h>
+
+#define	CL	':'
+#define	CM	','
+#define	NL	'\n'
+#define	MAXGRP	100
+
+static char GROUP[] = "/etc/group";
+static FILE *grf = NULL;
+static char line[BUFSIZ+1];
+static struct group group;
+static char *gr_mem[MAXGRP];
+
+setgrent()
+{
+	if( !grf )
+		grf = fopen( GROUP, "r" );
+	else
+		rewind( grf );
+}
+
+endgrent()
+{
+	if( grf ){
+		fclose( grf );
+		grf = NULL;
+	}
+}
+
+static char *
+grskip(register char *p, register c)
+{
+	while( *p && *p != c ) ++p;
+	if( *p ) *p++ = 0;
+	return( p );
+}
+
+struct group *
+getgrent()
+{
+	register char *p, **q;
+
+	if( !grf && !(grf = fopen( GROUP, "r" )) )
+		return(NULL);
+	if( !(p = fgets( line, BUFSIZ, grf )) )
+		return(NULL);
+	group.gr_name = p;
+	p = grskip(p,CL); /* passwd */
+	group.gr_gid = atoi(p = grskip(p,CL));
+	group.gr_mem = gr_mem;
+	p = grskip(p,CL);
+	grskip(p,NL);
+	q = gr_mem;
+	while( *p ){
+		*q++ = p;
+		p = grskip(p,CM);
+	}
+	*q = NULL;
+	return( &group );
+}
diff --git a/sys/src/ape/lib/ap/posix/getpwent.c b/sys/src/ape/lib/ap/posix/getpwent.c
new file mode 100755
index 000000000..779ae3a54
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/getpwent.c
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <pwd.h>
+#include <stdlib.h>
+
+static char PASSWD[]	= "/etc/passwd";
+static FILE *pwf = NULL;
+static char line[BUFSIZ+2];
+static struct passwd passwd;
+
+void
+setpwent(void)
+{
+	if( pwf == NULL )
+		pwf = fopen( PASSWD, "r" );
+	else
+		rewind( pwf );
+}
+
+void
+endpwent(void)
+{
+	if( pwf != NULL ){
+		fclose( pwf );
+		pwf = NULL;
+	}
+}
+
+static char *
+pwskip(char *p)
+{
+	while( *p && *p != ':' && *p != '\n' )
+		++p;
+	if( *p ) *p++ = 0;
+	else p[1] = 0;
+	return(p);
+}
+
+struct passwd *
+pwdecode(char *p)
+{
+	passwd.pw_name = p;
+	p = pwskip(p);
+	p = pwskip(p); /* passwd */
+	passwd.pw_uid = atoi(p);
+	p = pwskip(p);
+	passwd.pw_gid = atoi(p);
+	p = pwskip(p); /* comment */
+	p = pwskip(p); /* gecos */
+	passwd.pw_dir = p;
+	p = pwskip(p);
+	passwd.pw_shell = p;
+	p = pwskip(p);
+	return(&passwd);
+}
+
+struct passwd *
+getpwent(void)
+{
+	register char *p;
+
+	if (pwf == NULL) {
+		if( (pwf = fopen( PASSWD, "r" )) == NULL )
+			return(0);
+	}
+	p = fgets(line, BUFSIZ, pwf);
+	if (p==NULL)
+		return(0);
+	return pwdecode (p);
+}
diff --git a/sys/src/ape/lib/ap/posix/locale.c b/sys/src/ape/lib/ap/posix/locale.c
new file mode 100755
index 000000000..2468a3510
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/locale.c
@@ -0,0 +1,62 @@
+#include	<locale.h>
+#include	<limits.h>
+#include	<string.h>
+
+static struct lconv Clocale = {
+	".",		/* decimal_point */
+	"",		/* thousands_sep */
+	"",		/* grouping */
+	"",		/* int_curr_symbol */
+	"",		/* currency_symbol */
+	"",		/* mon_decimal_point */
+	"",		/* mon_thousands_sep */
+	"",		/* mon_grouping */
+	"",		/* positive_sign */
+	"",		/* negative_sign */
+	CHAR_MAX,	/* int_frac_digits */
+	CHAR_MAX,	/* frac_digits */
+	CHAR_MAX,	/* p_cs_precedes */
+	CHAR_MAX,	/* p_sep_by_space */
+	CHAR_MAX,	/* n_cs_precedes */
+	CHAR_MAX,	/* n_sep_by_space */
+	CHAR_MAX,	/* p_sign_posn */
+	CHAR_MAX,	/* n_sign_posn */
+};
+
+static char *localename[2] = {"C", ""};
+static short catlocale[6] = {0, 0, 0, 0, 0, 0};
+	/* indices into localename  for categories LC_ALL, LC_COLLATE, etc. */
+
+#define ASIZE(a) (sizeof(a)/sizeof(a[0]))
+
+char *
+setlocale(int category, const char *locale)
+{
+	int c, i;
+
+	if(category < 0 || category >= ASIZE(catlocale))
+		return 0;
+	if(!locale)
+		return localename[catlocale[category]];
+	for(c=0; c<ASIZE(localename); c++)
+		if(strcmp(locale, localename[c]) == 0)
+			break;
+	if(c >= ASIZE(localename))
+		return 0;
+	catlocale[category] = c;
+	if(category == LC_ALL)
+		for(i=0; i<ASIZE(catlocale); i++)
+			catlocale[i] = c;
+	return localename[c];
+}
+
+struct lconv *
+localeconv(void)
+{
+	/* BUG: posix says look at environment variables
+         * to set locale "", but we just make it the same
+	 * as C, always.
+	 */
+	return &Clocale;
+}
+
diff --git a/sys/src/ape/lib/ap/posix/mkfifo.c b/sys/src/ape/lib/ap/posix/mkfifo.c
new file mode 100755
index 000000000..7dbc8f5b6
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/mkfifo.c
@@ -0,0 +1,12 @@
+#include	<sys/types.h>
+#include	<sys/stat.h>
+#include	<errno.h>
+
+int
+mkfifo(char *path, mode_t mode)
+{
+#pragma ref path
+#pragma ref mode
+	errno = 0;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/posix/mkfile b/sys/src/ape/lib/ap/posix/mkfile
new file mode 100755
index 000000000..268a991d0
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/mkfile
@@ -0,0 +1,16 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	getgrent.$O\
+	getpwent.$O\
+	locale.$O\
+	mkfifo.$O\
+	pathconf.$O\
+	sigset.$O\
+	sysconf.$O\
+	tzset.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE
diff --git a/sys/src/ape/lib/ap/posix/pathconf.c b/sys/src/ape/lib/ap/posix/pathconf.c
new file mode 100755
index 000000000..9fdf47684
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/pathconf.c
@@ -0,0 +1,55 @@
+#include	<unistd.h>
+#include	<limits.h>
+#include	<errno.h>
+#include	<sys/limits.h>
+
+long
+pathconf(const char *path, int name)
+{
+#pragma ref path
+
+	switch(name)
+	{
+	case _PC_LINK_MAX:
+		return LINK_MAX;
+	case _PC_MAX_CANON:
+		return MAX_CANON;
+	case _PC_MAX_INPUT:
+		return MAX_INPUT;
+	case _PC_NAME_MAX:
+		return NAME_MAX;
+	case _PC_PATH_MAX:
+		return PATH_MAX;
+	case _PC_PIPE_BUF:
+		return PIPE_BUF;
+	case _PC_CHOWN_RESTRICTED:
+#ifdef _POSIX_CHOWN_RESTRICTED
+		return _POSIX_CHOWN_RESTRICTED;
+#else
+		return -1;
+#endif
+	case _PC_NO_TRUNC:
+#ifdef _POSIX_NO_TRUNC
+		return _POSIX_NO_TRUNC;
+#else
+		return -1;
+#endif
+	case _PC_VDISABLE:
+#ifdef _POSIX_VDISABLE
+		return _POSIX_VDISABLE;
+#else
+		return -1;
+#endif
+	}
+	errno = EINVAL;
+	return -1;
+}
+
+long
+fpathconf(int fd, int name)
+{
+#pragma ref fd
+
+	return pathconf(0, name);
+}
+
diff --git a/sys/src/ape/lib/ap/posix/sigset.c b/sys/src/ape/lib/ap/posix/sigset.c
new file mode 100755
index 000000000..1a9ef12aa
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/sigset.c
@@ -0,0 +1,67 @@
+#include <signal.h>
+#include <errno.h>
+
+/*
+ * sigsets are 32-bit longs.  if the 2<<(i-1) bit is on,
+ * the signal #define'd as i in signal.h is inluded.
+ */
+
+static sigset_t stdsigs = SIGHUP|SIGINT|SIGQUIT|SIGILL|SIGABRT|SIGFPE|SIGKILL|
+		SIGSEGV|SIGPIPE|SIGALRM|SIGTERM|SIGUSR1|SIGUSR2;
+
+#define BITSIG(s) (2<<(s))
+
+int
+sigemptyset(sigset_t *set)
+{
+	*set = 0;
+	return 0;
+}
+
+int
+sigfillset(sigset_t *set)
+{
+	*set = stdsigs;
+	return 0;
+}
+
+int
+sigaddset(sigset_t *set, int signo)
+{
+	int b;
+
+	b = BITSIG(signo);
+	if(!(b&stdsigs)){
+		errno = EINVAL;
+		return -1;
+	}
+	*set |= b;
+	return 0;
+}
+
+int
+sigdelset(sigset_t *set, int signo)
+{
+	int b;
+
+	b = BITSIG(signo);
+	if(!(b&stdsigs)){
+		errno = EINVAL;
+		return -1;
+	}
+	*set &= ~b;
+	return 0;
+}
+
+int
+sigismember(sigset_t *set, int signo)
+{
+	int b;
+
+	b = BITSIG(signo);
+	if(!(b&stdsigs)){
+		errno = EINVAL;
+		return -1;
+	}
+	return (b&*set)? 1 : 0;
+}
diff --git a/sys/src/ape/lib/ap/posix/sysconf.c b/sys/src/ape/lib/ap/posix/sysconf.c
new file mode 100755
index 000000000..cd7adaaab
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/sysconf.c
@@ -0,0 +1,42 @@
+#include	<stdio.h>
+#include	<unistd.h>
+#include	<limits.h>
+#include	<time.h>
+#include	<errno.h>
+#include	<sys/limits.h>
+
+long
+sysconf(int name)
+{
+	switch(name)
+	{
+	case _SC_ARG_MAX:
+		return ARG_MAX;
+	case _SC_CHILD_MAX:
+		return CHILD_MAX;
+	case _SC_CLK_TCK:
+		return CLOCKS_PER_SEC;
+	case _SC_NGROUPS_MAX:
+		return NGROUPS_MAX;
+	case _SC_OPEN_MAX:
+		return OPEN_MAX;
+	case _SC_JOB_CONTROL:
+#ifdef	_POSIX_JOB_CONTROL
+		return _POSIX_JOB_CONTROL;
+#else
+		return -1;
+#endif
+	case _SC_SAVED_IDS:
+#ifdef	_POSIX_SAVED_IDS
+		return _POSIX_SAVED_IDS;
+#else
+		return -1;
+#endif
+	case _SC_VERSION:
+		return _POSIX_VERSION;
+	case _SC_LOGIN_NAME_MAX:
+		return L_cuserid;
+	}
+	errno = EINVAL;
+	return -1;
+}
diff --git a/sys/src/ape/lib/ap/posix/tzset.c b/sys/src/ape/lib/ap/posix/tzset.c
new file mode 100755
index 000000000..8502c6d66
--- /dev/null
+++ b/sys/src/ape/lib/ap/posix/tzset.c
@@ -0,0 +1,141 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <time.h>
+#include <ctype.h>
+#include <string.h>
+#include <unistd.h>
+
+#define TZFILE	"/etc/TZ"
+
+static char TZ[128];
+static char std[32] = "GMT0";
+static char dst[32];
+char *tzname[2] = {
+	std, dst
+};
+time_t tzoffset, tzdstoffset;
+int tzdst = 0;
+
+static int
+offset(char *env, time_t *off)
+{
+	int n, sign;
+	size_t len, retlen;
+
+	retlen = 0;
+	sign = 1;
+	/*
+	 * strictly, no sign is allowed in the 'time' part of the
+	 * dst start/stop rules, but who cares?
+	 */
+	if (*env == '-' || *env == '+') {
+		if (*env++ == '-')
+			sign = -1;
+		retlen++;
+	}
+	if ((len = strspn(env, ":0123456789")) == 0)
+		return 0;
+	retlen += len;
+	for (*off = 0; len && isdigit(*env); len--)		/* hours */
+		*off = *off*10 + (*env++ - '0')*60*60;
+	if (len) {
+		if (*env++ != ':')
+			return 0;
+		len--;
+	}
+	for (n = 0; len && isdigit(*env); len--)		/* minutes */
+		n = n*10 + (*env++ - '0')*60;
+	*off += n;
+	if (len) {
+		if (*env++ != ':')
+			return 0;
+		len--;
+	}
+	for (n = 0; len && isdigit(*env); len--)		/* seconds */
+		n = n*10 + (*env++ - '0');
+	*off = (*off + n)*sign;
+	return retlen;
+}
+
+/*
+ * TZ=stdoffset[dst[offset][,start[/time],end[/time]]]
+ */
+void
+tzset(void)
+{
+	char *env, *p, envbuf[128];
+	int fd, i;
+	size_t len, retlen;
+	time_t off;
+
+	/*
+	 * get the TZ environment variable and check for validity.
+	 * the implementation-defined manner for dealing with the
+	 * leading ':' format is to reject it.
+	 * if it's ok, stash a copy away for quick comparison next time.
+	 */
+	if ((env = getenv("TZ")) == 0) {
+		if ((fd = open(TZFILE, O_RDONLY)) == -1)
+			return;
+		if (read(fd, envbuf, sizeof(envbuf)-1) == -1) {
+			close(fd);
+			return;
+		}
+		close(fd);
+		for (i = 0; i < sizeof(envbuf); i++) {
+			if (envbuf[i] != '\n')
+				continue;
+			envbuf[i] = '\0';
+			break;
+		}
+		env = envbuf;
+	}
+	if (strcmp(env, TZ) == 0)
+		return;
+	if (*env == 0 || *env == ':')
+		return;
+	strncpy(TZ, env, sizeof(TZ)-1);
+	TZ[sizeof(TZ)-1] = 0;
+	/*
+	 * get the 'std' string.
+	 * before committing, check there is a valid offset.
+	 */
+	if ((len = strcspn(env, ":0123456789,-+")) == 0)
+		return;
+	if ((retlen = offset(env+len, &off)) == 0)
+		return;
+	for (p = std, i = len+retlen; i; i--)
+		*p++ = *env++;
+	*p = 0;
+	tzoffset = -off;
+	/*
+	 * get the 'dst' string (if any).
+	 */
+	if (*env == 0 || (len = strcspn(env, ":0123456789,-+")) == 0)
+		return;
+	for (p = dst; len; len--)
+		*p++ = *env++;
+	*p = 0;
+	/*
+	 * optional dst offset.
+	 * default is one hour.
+	 */
+	tzdst = 1;
+	if (retlen = offset(env+len, &off)) {
+		tzdstoffset = -off;
+		env += retlen;
+	}
+	else
+		tzdstoffset = tzoffset + 60*60;
+	/*
+	 * optional rule(s) for start/end of dst.
+	 */
+	if (*env == 0 || *env != ',' || *(env+1) == 0)
+		return;
+	env++;
+	/*
+	 * we could go on...
+	 * but why bother?
+	 */
+}
diff --git a/sys/src/ape/lib/ap/power/cycles.s b/sys/src/ape/lib/ap/power/cycles.s
new file mode 100755
index 000000000..b4ad52367
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/cycles.s
@@ -0,0 +1,17 @@
+#define TBRL	268
+#define TBRU	269		/* Time base Upper/Lower (Reading) */
+
+/*
+ * time stamp counter; _cycles since power up
+ * Runs at fasthz/4 cycles per second (m->clkin>>3)
+ */
+TEXT _cycles(SB),1,$0
+loop:
+	MOVW	SPR(TBRU),R7
+	MOVW	SPR(TBRL),R8
+	MOVW	SPR(TBRU),R5
+	CMP	R5,R7
+	BNE	loop
+	MOVW	R7,0(R3)
+	MOVW	R8,4(R3)
+	RETURN
diff --git a/sys/src/ape/lib/ap/power/getfcr.s b/sys/src/ape/lib/ap/power/getfcr.s
new file mode 100755
index 000000000..b61d52e68
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/getfcr.s
@@ -0,0 +1,28 @@
+TEXT	getfcr(SB), $8
+	MOVFL	FPSCR, F3
+	FMOVD	F3, f-8(SP)
+	MOVW	-4(SP), R3
+	RETURN
+
+TEXT	getfsr(SB), $8
+	MOVFL	FPSCR, F3
+	FMOVD	F3, f-8(SP)
+	MOVW	-4(SP), R3
+	RETURN
+
+TEXT	setfcr(SB), $8
+	SYNC
+	MOVW	R3, -4(SP)
+	FMOVD	-8(SP), F3
+	MOVFL	F3, FPSCR
+	ISYNC
+	RETURN
+
+TEXT	setfsr(SB), $8
+	SYNC
+	MOVW	R3, -4(SP)
+	FMOVD	-8(SP), F3
+	MOVFL	F3, FPSCR
+	ISYNC
+	RETURN
+
diff --git a/sys/src/ape/lib/ap/power/lock.c b/sys/src/ape/lib/ap/power/lock.c
new file mode 100755
index 000000000..0d17c34d5
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/lock.c
@@ -0,0 +1,45 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#define _LOCK_EXTENSION
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	int i;
+
+	/* once fast */
+	if(!tas(&lk->val))
+		return;
+	/* a thousand times pretty fast */
+	for(i=0; i<1000; i++){
+		if(!tas(&lk->val))
+			return;
+		_SLEEP(0);
+	}
+	/* now nice and slow */
+	for(i=0; i<1000; i++){
+		if(!tas(&lk->val))
+			return;
+		_SLEEP(100);
+	}
+	/* take your time */
+	while(tas(&lk->val))
+		_SLEEP(1000);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/power/main9.s b/sys/src/ape/lib/ap/power/main9.s
new file mode 100755
index 000000000..ee493f5a8
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/main9.s
@@ -0,0 +1,14 @@
+TEXT	_main(SB), 1, $16
+
+	MOVW	$setSB(SB), R2
+
+	BL		_envsetup(SB)
+	MOVW	inargc-4(FP), R3
+	MOVW	$inargv+0(FP), R4
+	MOVW	R3, 4(R1)
+	MOVW	R4, 8(R1)
+	BL	main(SB)
+loop:
+	MOVW	R3, 4(R1)
+	BL	exit(SB)
+	BR	loop
diff --git a/sys/src/ape/lib/ap/power/main9p.s b/sys/src/ape/lib/ap/power/main9p.s
new file mode 100755
index 000000000..865616980
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/main9p.s
@@ -0,0 +1,46 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+
+	MOVW	$setSB(SB), R2
+
+	/* _tos = arg */
+	MOVW	R3, _tos(SB)
+	MOVW	$8(SP), R1
+	MOVW	R1, _privates(SB)
+	MOVW	$NPRIVATES, R1
+	MOVW	R1, _nprivates(SB)
+
+	/* _profmain(); */
+	BL	_envsetup(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVW	_tos+0(SB),R1
+	MOVW	4(R1),R2
+	MOVW	R2,(R1)
+
+	/* main(argc, argv, environ); */
+	MOVW	inargc-4(FP), R3
+	MOVW	$inargv+0(FP), R4
+	MOVW	environ(SB), R5
+	MOVW	R3, 4(R1)
+	MOVW	R4, 8(R1)
+	MOVW	R5, 12(R1)
+	BL	main(SB)
+loop:
+	MOVW	R3, 4(R1)
+	BL	exit(SB)
+	MOVW	$_profin(SB), R4	/* force loading of profile */
+	BR	loop
+
+TEXT	_savearg(SB), 1, $0
+	RETURN
+
+TEXT	_callpc(SB), 1, $0
+	MOVW	argp+0(FP), R3
+	MOVW	4(R3), R3
+	RETURN
diff --git a/sys/src/ape/lib/ap/power/memcmp.s b/sys/src/ape/lib/ap/power/memcmp.s
new file mode 100755
index 000000000..f524fa9d3
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/memcmp.s
@@ -0,0 +1,110 @@
+	TEXT	memcmp(SB), $0
+#define	BDNZ	BC	16,0,
+	MOVW R3, s1+0(FP)		/* R3 is pointer1 */
+
+/*
+ * performance:
+ *	67mb/sec aligned; 16mb/sec unaligned
+ */
+
+	MOVW	n+8(FP), R4		/* R4 is count */
+	MOVW	s2+4(FP), R5		/* R5 is pointer2 */
+
+/*
+ * let LSW do the work for 4 characters or less; aligned and unaligned
+ */
+	CMP	R4, $0
+	BLE	eq
+	CMP	R4, $4
+	BLE	out
+
+	XOR	R3, R5, R9
+	ANDCC	$3, R9
+	BNE	l4	/* pointers misaligned; use LSW loop */
+
+/*
+ * do enough bytes to align pointers
+ */
+	ANDCC	$3,R3, R9
+	BEQ	l2
+	SUBC	R9, $4, R9
+	MOVW	R9, XER
+	LSW	(R3), R10
+	ADD	R9, R3
+	LSW	(R5), R14
+	ADD	R9, R5
+	SUB	R9, R4
+	CMPU	R10, R14
+	BNE	ne
+
+/*
+ * compare 16 at a time
+ */
+l2:
+	SRAWCC	$4, R4, R9
+	BLE	l4
+	MOVW	R9, CTR
+	SUB	$4, R3
+	SUB	$4, R5
+l3:
+	MOVWU	4(R3), R10
+	MOVWU	4(R5), R12
+	MOVWU	4(R3), R11
+	MOVWU	4(R5), R13
+	CMPU	R10, R12
+	BNE	ne
+	MOVWU	4(R3), R10
+	MOVWU	4(R5), R12
+	CMPU	R11, R13
+	BNE	ne
+	MOVWU	4(R3), R11
+	MOVWU	4(R5), R13
+	CMPU	R10, R12
+	BNE	ne
+	CMPU	R11, R13
+	BNE	ne
+	BDNZ	l3
+	ADD	$4, R3
+	ADD	$4, R5
+	RLWNMCC	$0, R4, $15, R4	/* residue */
+	BEQ	eq
+
+/*
+ * do remaining words with LSW; also does unaligned case
+ */
+l4:
+	SRAWCC	$2, R4, R9
+	BLE	out
+	MOVW	R9, CTR
+l5:
+	LSW	(R3), $4, R10
+	ADD	$4, R3
+	LSW	(R5), $4, R11
+	ADD	$4, R5
+	CMPU	R10, R11
+	BNE	ne
+	BDNZ	l5
+	RLWNMCC	$0, R4, $3, R4	/* residue */
+	BEQ	eq
+
+/*
+ * do remaining bytes with final LSW
+ */
+out:
+	MOVW	R4, XER
+	LSW	(R3), R10
+	LSW	(R5), R11
+	CMPU	R10, R11
+	BNE	ne
+
+eq:
+	MOVW	$0, R3
+	RETURN
+
+ne:
+	MOVW	$1, R3
+	BGE	ret
+	MOVW	$-1,R3
+ret:
+	RETURN
+	END
diff --git a/sys/src/ape/lib/ap/power/memmove.s b/sys/src/ape/lib/ap/power/memmove.s
new file mode 100755
index 000000000..dd6167d7d
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/memmove.s
@@ -0,0 +1,170 @@
+#define	BDNZ	BC	16,0,
+	TEXT	memmove(SB), $0
+	BR	move
+
+	TEXT	memcpy(SB), $0
+move:
+
+/*
+ * performance:
+ * (tba)
+ */
+
+	MOVW	R3, s1+0(FP)
+	MOVW	n+8(FP), R9		/* R9 is count */
+	MOVW	R3, R10			/* R10 is to-pointer */
+	CMP	R9, $0
+	BEQ	ret
+	BLT	trap
+	MOVW	s2+4(FP), R11		/* R11 is from-pointer */
+
+/*
+ * if no more than 16 bytes, just use one lsw/stsw
+ */
+	CMP	R9, $16
+	BLE	fout
+
+	ADD	R9,R11, R13		/* R13 is end from-pointer */
+	ADD	R9,R10, R12		/* R12 is end to-pointer */
+
+/*
+ * easiest test is copy backwards if
+ * destination string has higher mem address
+ */
+	CMPU	R10, R11
+	BGT	back
+
+/*
+ * test if both pointers
+ * are similarly word aligned
+ */
+	XOR	R10,R11, R7
+	ANDCC	$3,R7
+	BNE	fbad
+
+/*
+ * move a few bytes to align pointers
+ */
+	ANDCC	$3,R10,R7
+	BEQ	f2
+	SUBC	R7, $4, R7
+	SUB	R7, R9
+	MOVW	R7, XER
+	LSW	(R11), R16
+	ADD	R7, R11
+	STSW	R16, (R10)
+	ADD	R7, R10
+
+/*
+ * turn R14 into doubleword count
+ * copy 16 bytes at a time while there's room.
+ */
+f2:
+	SRAWCC	$4, R9, R14
+	BLE	fout
+	MOVW	R14, CTR
+	SUB	$4, R11
+	SUB	$4, R10
+f3:
+	MOVWU	4(R11), R16
+	MOVWU	R16, 4(R10)
+	MOVWU	4(R11), R17
+	MOVWU	R17, 4(R10)
+	MOVWU	4(R11), R16
+	MOVWU	R16, 4(R10)
+	MOVWU	4(R11), R17
+	MOVWU	R17, 4(R10)
+	BDNZ	f3
+	RLWNMCC	$0, R9, $15, R9	/* residue */
+	BEQ	ret
+	ADD	$4, R11
+	ADD	$4, R10
+
+/*
+ * move up to 16 bytes through R16 .. R19; aligned and unaligned
+ */
+fout:
+	MOVW	R9, XER
+	LSW	(R11), R16
+	STSW	R16, (R10)
+	BR	ret
+
+/*
+ * loop for unaligned copy, then copy up to 15 remaining bytes
+ */
+fbad:
+	SRAWCC	$4, R9, R14
+	BLE	f6
+	MOVW	R14, CTR
+f5:
+	LSW	(R11), $16, R16
+	ADD	$16, R11
+	STSW	R16, $16, (R10)
+	ADD	$16, R10
+	BDNZ	f5
+	RLWNMCC	$0, R9, $15, R9	/* residue */
+	BEQ	ret
+f6:
+	MOVW	R9, XER
+	LSW	(R11), R16
+	STSW	R16, (R10)
+	BR	ret
+
+/*
+ * whole thing repeated for backwards
+ */
+back:
+	CMP	R9, $4
+	BLT	bout
+
+	XOR	R12,R13, R7
+	ANDCC	$3,R7
+	BNE	bout
+b1:
+	ANDCC	$3,R13, R7
+	BEQ	b2
+	MOVBZU	-1(R13), R16
+	MOVBZU	R16, -1(R12)
+	SUB	$1, R9
+	BR	b1
+b2:
+	SRAWCC	$4, R9, R14
+	BLE	b4
+	MOVW	R14, CTR
+b3:
+	MOVWU	-4(R13), R16
+	MOVWU	R16, -4(R12)
+	MOVWU	-4(R13), R17
+	MOVWU	R17, -4(R12)
+	MOVWU	-4(R13), R16
+	MOVWU	R16, -4(R12)
+	MOVWU	-4(R13), R17
+	MOVWU	R17, -4(R12)
+	BDNZ	b3
+	RLWNMCC	$0, R9, $15, R9	/* residue */
+	BEQ	ret
+b4:
+	SRAWCC	$2, R9, R14
+	BLE	bout
+	MOVW	R14, CTR
+b5:
+	MOVWU	-4(R13), R16
+	MOVWU	R16, -4(R12)
+	BDNZ	b5
+	RLWNMCC	$0, R9, $3, R9	/* residue */
+	BEQ	ret
+
+bout:
+	CMPU	R13, R11
+	BLE	ret
+	MOVBZU	-1(R13), R16
+	MOVBZU	R16, -1(R12)
+	BR	bout
+
+trap:
+	MOVW	$0, R0
+	MOVW	0(R0), R0
+
+ret:
+	MOVW	s1+0(FP), R3
+	RETURN
diff --git a/sys/src/ape/lib/ap/power/memset.s b/sys/src/ape/lib/ap/power/memset.s
new file mode 100755
index 000000000..fa6e8d920
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/memset.s
@@ -0,0 +1,73 @@
+	TEXT	memset(SB),$0
+#define	BDNZ	BC	16,0,
+	MOVW R3, p+0(FP)		/* R3 is pointer */
+
+/*
+ * performance:
+ *	about 100mbytes/sec (8k blocks) on a 603/105 without L2 cache
+ *	drops to 40mbytes/sec (10k blocks) and 28mbytes/sec with 32k blocks
+ */
+
+	MOVW	n+8(FP), R4		/* R4 is count */
+	CMP	R4, $0
+	BLE	ret
+	MOVW	c+4(FP), R5		/* R5 is char */
+
+/*
+ * create 16 copies of c in R5 .. R8
+ */
+	RLWNM	$0, R5, $0xff, R5
+	RLWMI	$8, R5, $0xff00, R5
+	RLWMI	$16, R5, $0xffff0000, R5
+	MOVW	R5, R6
+	MOVW	R5, R7
+	MOVW	R5, R8
+
+/*
+ * let STSW do the work for 16 characters or less; aligned and unaligned
+ */
+	CMP	R4, $16
+	BLE	out
+
+/*
+ * store enough bytes to align pointer
+ */
+	ANDCC	$7,R3, R9
+	BEQ	l2
+	SUBC	R9, $8, R9
+	MOVW	R9, XER
+	STSW	R5, (R3)
+	ADD	R9, R3
+	SUB	R9, R4
+
+/*
+ * store 16 at a time while there's room
+ * STSW was used here originally, but it's `completion serialised'
+ */
+l2:
+	SRAWCC	$4, R4, R9
+	BLE	out
+	MOVW	R9, CTR
+l3:
+	MOVW	R5, 0(R3)
+	ADD	$8, R3, R10
+	MOVW	R6, 4(R3)
+	MOVW	R7, 0(R10)
+	ADD	$8, R10, R3
+	MOVW	R8, 4(R10)
+	BDNZ	l3
+	RLWNMCC	$0, R4, $15, R4	/* residue */
+	BEQ	ret
+
+/*
+ * store up to 16 bytes from R5 .. R8; aligned and unaligned
+ */
+
+out:
+	MOVW	R4, XER
+	STSW	R5, (R3)
+
+ret:
+	MOVW	0(FP), R3
+	RETURN
+	END
diff --git a/sys/src/ape/lib/ap/power/mkfile b/sys/src/ape/lib/ap/power/mkfile
new file mode 100755
index 000000000..cc546cd84
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/mkfile
@@ -0,0 +1,23 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	getfcr.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memcmp.$O\
+	memmove.$O\
+	memset.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strcmp.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/power/notetramp.c b/sys/src/ape/lib/ap/power/notetramp.c
new file mode 100755
index 000000000..6477e1b14
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/notetramp.c
@@ -0,0 +1,72 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r3 = ret;
+	if(ret == 0)
+		u->r3 = 1;
+	u->pc = j[2+JMPBUFPC];
+	u->sp = j[2+JMPBUFSP];
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/power/setjmp.s b/sys/src/ape/lib/ap/power/setjmp.s
new file mode 100755
index 000000000..0023afcf2
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/setjmp.s
@@ -0,0 +1,37 @@
+TEXT	setjmp(SB), 1, $-4
+	MOVW	LR, R4
+	MOVW	R1, (R3)
+	MOVW	R4, 4(R3)
+	MOVW	$0, R3
+	RETURN
+
+TEXT	sigsetjmp(SB), 1, $-4
+	MOVW	savemask+4(FP), R4
+	MOVW	R4, 0(R3)
+	MOVW	$_psigblocked(SB), R4
+	MOVW	R4, 4(R3)
+	MOVW	LR, R4
+	MOVW	R1, 8(R3)
+	MOVW	R4, 12(R3)
+	MOVW	$0, R3
+	RETURN
+
+TEXT	longjmp(SB), 1, $-4
+	MOVW	R3, R4
+	MOVW	r+4(FP), R3
+	CMP	R3, $0
+	BNE	ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVW	$1, R3		/* bless their pointed heads */
+ok:	MOVW	(R4), R1
+	MOVW	4(R4), R4
+	MOVW	R4, LR
+	BR	(LR)
+
+/*
+ * trampoline functions because the kernel smashes r1
+ * in the uregs given to notejmp
+ */
+TEXT	__noterestore(SB), 1, $-4
+	MOVW	R4, R3
+	MOVW	R5, LR
+	BR	(LR)
diff --git a/sys/src/ape/lib/ap/power/strcmp.s b/sys/src/ape/lib/ap/power/strcmp.s
new file mode 100755
index 000000000..0aef5b29c
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/strcmp.s
@@ -0,0 +1,21 @@
+TEXT	strcmp(SB), $0
+
+	MOVW	s2+4(FP), R4
+
+	SUB	$1, R3
+	SUB	$1, R4
+l1:
+	MOVBZU	1(R3), R5
+	MOVBZU	1(R4), R6
+	CMP	R5, R6
+	BNE	ne
+	CMP	R5, $0
+	BNE	l1
+	MOVW	$0, R3
+	RETURN
+ne:
+	MOVW	$1, R3
+	BGT	ret
+	MOVW	$-1, R3
+ret:
+	RETURN
diff --git a/sys/src/ape/lib/ap/power/tas.s b/sys/src/ape/lib/ap/power/tas.s
new file mode 100755
index 000000000..09fb0c492
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/tas.s
@@ -0,0 +1,16 @@
+TEXT	tas(SB), $0
+	SYNC
+	MOVW	R3, R4
+	MOVW	$0xdeaddead,R5
+tas1:
+	DCBF	(R4)	/* fix for 603x bug */
+	LWAR	(R4), R3
+	CMP	R3, $0
+	BNE	tas0
+	DCBT	(R4)				/* fix 405 errata cpu_210 */
+	STWCCC	R5, (R4)
+	BNE	tas1
+tas0:
+	SYNC
+	ISYNC
+	RETURN
diff --git a/sys/src/ape/lib/ap/power/vlop.s b/sys/src/ape/lib/ap/power/vlop.s
new file mode 100755
index 000000000..9085da247
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/vlop.s
@@ -0,0 +1,132 @@
+#define	BDNZ	BC	16,0,
+
+/*
+ * 64/64 division adapted from powerpc compiler writer's handbook
+ *
+ * (R3:R4) = (R3:R4) / (R5:R6) (64b) = (64b / 64b)
+ * quo dvd dvs
+ *
+ * Remainder is left in R7:R8
+ *
+ * Code comment notation:
+ * msw = most-significant (high-order) word, i.e. bits 0..31
+ * lsw = least-significant (low-order) word, i.e. bits 32..63
+ * LZ = Leading Zeroes
+ * SD = Significant Digits
+ *
+ * R3:R4 = dvd (input dividend); quo (output quotient)
+ * R5:R6 = dvs (input divisor)
+ *
+ * R7:R8 = tmp; rem (output remainder)
+ */
+
+TEXT	_divu64(SB), $0
+	MOVW	a+0(FP), R3
+	MOVW	a+4(FP), R4
+	MOVW	b+8(FP), R5
+	MOVW	b+12(FP), R6
+
+	/*  count the number of leading 0s in the dividend */
+	CMP	R3, $0 	/*  dvd.msw == 0? 	R3, */
+	CNTLZW 	R3, R11 	/*  R11 = dvd.msw.LZ */
+	CNTLZW 	R4, R9 	/*  R9 = dvd.lsw.LZ */
+	BNE 	lab1 	/*  if(dvd.msw != 0) dvd.LZ = dvd.msw.LZ */
+	ADD 	$32, R9, R11 	/*  dvd.LZ = dvd.lsw.LZ + 32 */
+
+lab1:
+	/*  count the number of leading 0s in the divisor */
+	CMP 	R5, $0 	/*  dvd.msw == 0? */
+	CNTLZW 	R5, R9 	/*  R9 = dvs.msw.LZ */
+	CNTLZW 	R6, R10 	/*  R10 = dvs.lsw.LZ */
+	BNE 	lab2 	/*  if(dvs.msw != 0) dvs.LZ = dvs.msw.LZ */
+	ADD 	$32, R10, R9 	/*  dvs.LZ = dvs.lsw.LZ + 32 */
+
+lab2:
+	/*  determine shift amounts to minimize the number of iterations */
+	CMP 	R11, R9 	/*  compare dvd.LZ to dvs.LZ */
+	SUBC	R11, $64, R10	/*  R10 = dvd.SD */
+	BGT 	lab9 	/*  if(dvs > dvd) quotient = 0 */
+	ADD 	$1, R9 	/*  ++dvs.LZ (or --dvs.SD) */
+	SUBC 	R9, $64, R9 	/*  R9 = dvs.SD */
+	ADD 	R9, R11 	/*  (dvd.LZ + dvs.SD) = left shift of dvd for */
+			/*  initial dvd */
+	SUB		R9, R10, R9 	/*  (dvd.SD - dvs.SD) = right shift of dvd for */
+			/*  initial tmp */
+	MOVW 	R9, CTR 	/*  number of iterations = dvd.SD - dvs.SD */
+
+	/*  R7:R8 = R3:R4 >> R9 */
+	CMP 	 R9, $32
+	ADD	$-32, R9, R7
+	BLT	lab3 	/*  if(R9 < 32) jump to lab3 */
+	SRW	R7, R3, R8 	/*  tmp.lsw = dvd.msw >> (R9 - 32) */
+	MOVW 	$0, R7 	/*  tmp.msw = 0 */
+	BR 	lab4
+lab3:
+	SRW	R9, R4, R8 	/*  R8 = dvd.lsw >> R9 */
+	SUBC	R9, $32, R7
+	SLW	R7, R3, R7		/*  R7 = dvd.msw << 32 - R9 */
+	OR	R7, R8 		/*  tmp.lsw = R8 | R7 */
+	SRW	R9, R3, R7		/*  tmp.msw = dvd.msw >> R9 */
+
+lab4:
+	/*  R3:R4 = R3:R4 << R11 */
+	CMP	R11,$32
+	ADDC	$-32, R11, R9
+	BLT 	lab5 	/*  (R11 < 32)? */
+	SLW	R9, R4, R3	/*  dvd.msw = dvs.lsw << R9 */
+	MOVW 	$0, R4 	/*  dvd.lsw = 0 */
+	BR 	lab6
+
+lab5:
+	SLW	R11, R3	/*  R3 = dvd.msw << R11 */
+	SUBC	R11, $32, R9
+	SRW	R9, R4, R9	/*  R9 = dvd.lsw >> 32 - R11 */
+	OR	R9, R3	/*  dvd.msw = R3 | R9 */
+	SLW	R11, R4	/*  dvd.lsw = dvd.lsw << R11 */
+
+lab6:
+	/*  restoring division shift and subtract loop */
+	MOVW	$-1, R10
+	ADDC	$0, R7	/*  clear carry bit before loop starts */
+lab7:
+	/*  tmp:dvd is considered one large register */
+	/*  each portion is shifted left 1 bit by adding it to itself */
+	/*  adde sums the carry from the previous and creates a new carry */
+	ADDE 	R4,R4 	/*  shift dvd.lsw left 1 bit */
+	ADDE 	R3,R3 	/*  shift dvd.msw to left 1 bit */
+	ADDE 	R8,R8 	/*  shift tmp.lsw to left 1 bit */
+	ADDE 	R7,R7 	/*  shift tmp.msw to left 1 bit */
+	SUBC	R6, R8, R11	/*  tmp.lsw - dvs.lsw */
+	SUBECC	R5, R7, R9	/*  tmp.msw - dvs.msw */
+	BLT 	lab8 	/*  if(result < 0) clear carry bit */
+	MOVW	R11, R8 	/*  move lsw */
+	MOVW	R9, R7	/*  move msw */
+	ADDC 	$1, R10, R11 	/*  set carry bit */
+lab8:
+	BDNZ 	lab7
+
+	ADDE 	R4,R4 	/*  quo.lsw (lsb = CA) */
+	ADDE 	R3,R3 	/*  quo.msw (lsb from lsw) */
+
+lab10:
+	MOVW	qp+16(FP), R9
+	MOVW	rp+20(FP), R10
+	CMP	R9, $0
+	BEQ	lab11
+	MOVW	R3, 0(R9)
+	MOVW	R4, 4(R9)
+lab11:
+	CMP	R10, $0
+	BEQ	lab12
+	MOVW	R7, 0(R10)
+	MOVW	R8, 4(R10)
+lab12:
+	RETURN
+
+lab9:
+	/*  Quotient is 0 (dvs > dvd) */
+	MOVW	R4, R8	/*  rmd.lsw = dvd.lsw */
+	MOVW	R3, R7	/*  rmd.msw = dvd.msw */
+	MOVW	$0, R4	/*  dvd.lsw = 0 */
+	MOVW	$0, R3	/*  dvd.msw = 0 */
+	BR	lab10
diff --git a/sys/src/ape/lib/ap/power/vlrt.c b/sys/src/ape/lib/ap/power/vlrt.c
new file mode 100755
index 000000000..681a3b49b
--- /dev/null
+++ b/sys/src/ape/lib/ap/power/vlrt.c
@@ -0,0 +1,254 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	ulong	hi;
+	ulong	lo;
+};
+
+void	abort(void);
+void	_divu64(Vlong, Vlong, Vlong*, Vlong*);
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	_divu64(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	_divu64(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	_divu64(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	_divu64(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u = *ret;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
diff --git a/sys/src/ape/lib/ap/sparc/cycles.c b/sys/src/ape/lib/ap/sparc/cycles.c
new file mode 100755
index 000000000..1c32bc732
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/cycles.c
@@ -0,0 +1,5 @@
+void
+_cycles(unsigned long long *u)
+{
+	*u = 0;
+}
diff --git a/sys/src/ape/lib/ap/sparc/lock.c b/sys/src/ape/lib/ap/sparc/lock.c
new file mode 100755
index 000000000..91c0ba233
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/lock.c
@@ -0,0 +1,26 @@
+#define _LOCK_EXTENSION
+#include "../plan9/sys9.h"
+#include <lock.h>
+
+int	tas(int*);
+
+void
+lock(Lock *lk)
+{
+	while(tas(&lk->val))
+		_SLEEP(0);
+}
+
+int
+canlock(Lock *lk)
+{
+	if(tas(&lk->val))
+		return 0;
+	return 1;
+}
+
+void
+unlock(Lock *lk)
+{
+	lk->val = 0;
+}
diff --git a/sys/src/ape/lib/ap/sparc/main9.s b/sys/src/ape/lib/ap/sparc/main9.s
new file mode 100755
index 000000000..24a9f6f53
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/main9.s
@@ -0,0 +1,14 @@
+	TEXT	_main(SB), $16
+	MOVW	$setSB(SB), R2
+	JMPL	_envsetup(SB)
+	MOVW	inargc-4(FP), R7
+	MOVW	$inargv+0(FP), R8
+	MOVW	R7, 4(R1)
+	MOVW	R8, 8(R1)
+	JMPL	main(SB)
+
+loop:
+	MOVW	R7, 4(R1)
+	JMPL	exit(SB)
+	MOVW	$_mul(SB),R7
+	JMP	loop
diff --git a/sys/src/ape/lib/ap/sparc/main9p.s b/sys/src/ape/lib/ap/sparc/main9p.s
new file mode 100755
index 000000000..17cc3e2af
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/main9p.s
@@ -0,0 +1,53 @@
+#define NPRIVATES	16
+
+GLOBL	_tos(SB), $4
+GLOBL	_privates(SB), $4
+GLOBL	_nprivates(SB), $4
+
+TEXT	_mainp(SB), 1, $(3*4+NPRIVATES*4)
+	MOVW	$setSB(SB), R2
+
+	/* _tos = arg */
+	MOVW	R7, _tos(SB)
+/*
+	MOVW	_fpsr+0(SB), FSR
+	FMOVD	$0.5, F26
+	FSUBD	F26, F26, F24
+	FADDD	F26, F26, F28
+	FADDD	F28, F28, F30
+*/
+	MOVW	$8(SP), R1
+	MOVW	R1, _privates(SB)
+	MOVW	$NPRIVATES, R1
+	MOVW	R1, _nprivates(SB)
+
+	/* _profmain(); */
+	JMPL	_profmain(SB)
+
+	/* _tos->prof.pp = _tos->prof.next; */
+	MOVW	_tos+0(SB),R7
+	MOVW	4(R7),R8
+	MOVW	R8,(R7)
+
+	JMPL	_envsetup(SB)
+
+	/* main(argc, argv, environ); */
+	MOVW	inargc-4(FP), R7
+	MOVW	$inargv+0(FP), R8
+	MOVW	environ(SB), R9
+	MOVW	R8, 8(R1)
+	MOVW	R9, 12(R1)
+	JMPL	main(SB)
+
+loop:
+	JMPL	exit(SB)
+	MOVW	$_mul(SB), R0		/* force loading of muldiv */
+	MOVW	$_profin(SB), R0	/* force loading of profile */
+	JMP	loop
+
+TEXT	_savearg(SB), 1, $0
+	RETURN
+
+TEXT	_callpc(SB), 1, $0
+	MOVW	argp-4(FP), R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/memchr.s b/sys/src/ape/lib/ap/sparc/memchr.s
new file mode 100755
index 000000000..81e67f6f2
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/memchr.s
@@ -0,0 +1,26 @@
+	TEXT	memchr(SB), $0
+
+MOVW	R7, 0(FP)
+	MOVW	n+8(FP), R7
+	SUBCC	R0,R7, R0
+	BE	ret
+	MOVW	s1+0(FP), R8
+	MOVBU	c+7(FP), R9
+	ADD	R7,R8, R11
+
+l1:
+	MOVBU	(R8), R10
+	SUBCC	R9,R10, R0
+	ADD	$1, R8
+	BE	eq
+	SUBCC	R8,R11, R0
+	BNE	l1
+
+	MOVW	R0, R7
+	RETURN
+
+eq:
+	SUB	$1,R8, R7
+
+ret:
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/memcmp.s b/sys/src/ape/lib/ap/sparc/memcmp.s
new file mode 100755
index 000000000..2b470d549
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/memcmp.s
@@ -0,0 +1,122 @@
+#define	Bxx	BE
+
+	TEXT	memcmp(SB), $0
+
+/*
+ * performance:
+ *	(tba)
+ */
+
+MOVW	R7, 0(FP)
+	MOVW	n+8(FP), R9		/* R9 is count */
+	MOVW	s1+0(FP), R10		/* R10 is pointer1 */
+	MOVW	s2+4(FP), R11		/* R11 is pointer2 */
+	ADD	R9,R10, R12		/* R12 is end pointer1 */
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word cmp.
+ */
+	SUBCC	$4,R9, R0
+	BL	out
+
+/*
+ * test if both pointers
+ * are similarly word alligned
+ */
+	XOR	R10,R11, R7
+	ANDCC	$3,R7, R0
+	BNE	out
+
+/*
+ * byte at a time to word allign
+ */
+l1:
+	ANDCC	$3,R10, R0
+	BE	l2
+	MOVB	0(R10), R16
+	MOVB	0(R11), R17
+	ADD	$1, R10
+	SUBCC	R16,R17, R0
+	BNE	ne
+	ADD	$1, R11
+	JMP	l1
+
+/*
+ * turn R9 into end pointer1-15
+ * cmp 16 at a time while theres room
+ */
+l2:
+	SUB	$15,R12, R9
+l3:
+	SUBCC	R10,R9, R0
+	BLEU	l4
+	MOVW	0(R10), R16
+	MOVW	0(R11), R17
+	MOVW	4(R10), R18
+	SUBCC	R16,R17, R0
+	BNE	ne
+	MOVW	4(R11), R19
+	MOVW	8(R10), R16
+	SUBCC	R18,R19, R0
+	BNE	ne
+	MOVW	8(R11), R17
+	MOVW	12(R10), R18
+	SUBCC	R16,R17, R0
+	BNE	ne
+	MOVW	12(R11), R19
+	ADD	$16, R10
+	SUBCC	R18,R19, R0
+	BNE	ne
+	SUBCC	R16,R17, R0
+	BNE	ne
+	ADD	$16, R11
+	JMP	l3
+
+/*
+ * turn R9 into end pointer1-3
+ * cmp 4 at a time while theres room
+ */
+l4:
+	SUB	$3,R12, R9
+l5:
+	SUBCC	R10,R9, R0
+	BLEU	out
+	MOVW	0(R10), R16
+	MOVW	0(R11), R17
+	ADD	$4, R10
+	SUBCC	R16,R17, R0		/* only works because big endian */
+	BNE	ne
+	ADD	$4, R11
+	JMP	l5
+
+/*
+ * last loop, cmp byte at a time
+ */
+out:
+	SUBCC	R10,R12, R0
+	BE	zero
+	MOVB	0(R10), R16
+	MOVB	0(R11), R17
+	ADD	$1, R10
+	SUBCC	R16,R17, R0
+	BNE	ne
+	ADD	$1, R11
+	JMP	out
+
+ne:
+	BG	plus
+	MOVW	$1, R7
+	RETURN
+plus:
+	MOVW	$-1, R7
+	RETURN
+
+zero:
+	MOVW	R0, R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/memmove.s b/sys/src/ape/lib/ap/sparc/memmove.s
new file mode 100755
index 000000000..8879a74e8
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/memmove.s
@@ -0,0 +1,169 @@
+	TEXT	memmove(SB), $0
+	JMP	move
+
+	TEXT	memcpy(SB), $0
+move:
+
+/*
+ * performance:
+ * (tba)
+ */
+
+	MOVW	R7, s1+0(FP)
+	MOVW	n+8(FP), R9		/* R9 is count */
+	MOVW	R7, R10			/* R10 is to-pointer */
+	SUBCC	R0,R9, R0
+	BGE	ok
+	MOVW	0(R0), R0
+
+ok:
+	MOVW	s2+4(FP), R11		/* R11 is from-pointer */
+	ADD	R9,R11, R13		/* R13 is end from-pointer */
+	ADD	R9,R10, R12		/* R12 is end to-pointer */
+
+/*
+ * easiest test is copy backwards if
+ * destination string has higher mem address
+ */
+	SUBCC	R11,R10, R0
+	BGU	back
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word store.
+ */
+	SUBCC	$4,R9, R0
+	BL	fout
+
+/*
+ * test if both pointers
+ * are similarly word aligned
+ */
+	XOR	R10,R11, R7
+	ANDCC	$3,R7, R0
+	BNE	fout
+
+/*
+ * byte at a time to word align
+ */
+f1:
+	ANDCC	$3,R10, R0
+	BE	f2
+	MOVB	0(R11), R16
+	ADD	$1, R11
+	MOVB	R16, 0(R10)
+	ADD	$1, R10
+	JMP	f1
+
+/*
+ * turn R9 into to-end pointer-15
+ * copy 16 at a time while theres room.
+ * R12 is smaller than R13 --
+ * there are problems if R13 is 0.
+ */
+f2:
+	SUB	$15,R12, R9
+f3:
+	SUBCC	R10,R9, R0
+	BLEU	f4
+	MOVW	0(R11), R16
+	MOVW	4(R11), R17
+	MOVW	R16, 0(R10)
+	MOVW	8(R11), R16
+	MOVW	R17, 4(R10)
+	MOVW	12(R11), R17
+	ADD	$16, R11
+	MOVW	R16, 8(R10)
+	MOVW	R17, 12(R10)
+	ADD	$16, R10
+	JMP	f3
+
+/*
+ * turn R9 into to-end pointer-3
+ * copy 4 at a time while theres room
+ */
+f4:
+	SUB	$3,R12, R9
+f5:
+	SUBCC	R10,R9, R0
+	BLEU	fout
+	MOVW	0(R11), R16
+	ADD	$4, R11
+	MOVW	R16, 0(R10)
+	ADD	$4, R10
+	JMP	f5
+
+/*
+ * last loop, copy byte at a time
+ */
+fout:
+	SUBCC	R11,R13, R0
+	BLEU	ret
+	MOVB	0(R11), R16
+	ADD	$1, R11
+	MOVB	R16, 0(R10)
+	ADD	$1, R10
+	JMP	fout
+
+/*
+ * whole thing repeated for backwards
+ */
+back:
+	SUBCC	$4,R9, R0 
+	BL	bout
+
+	XOR	R12,R13, R7
+	ANDCC	$3,R7, R0
+	BNE	bout
+b1:
+	ANDCC	$3,R13, R0
+	BE	b2
+	MOVB	-1(R13), R16
+	SUB	$1, R13
+	MOVB	R16, -1(R12)
+	SUB	$1, R12
+	JMP	b1
+b2:
+	ADD	$15,R11, R9
+b3:
+	SUBCC	R9,R13, R0
+	BLEU	b4
+	MOVW	-4(R13), R16
+	MOVW	-8(R13), R17
+	MOVW	R16, -4(R12)
+	MOVW	-12(R13), R16
+	MOVW	R17, -8(R12)
+	MOVW	-16(R13), R17
+	SUB	$16, R13
+	MOVW	R16, -12(R12)
+	MOVW	R17, -16(R12)
+	SUB	$16, R12
+	JMP	b3
+b4:
+	ADD	$3,R11, R9
+b5:
+	SUBCC	R9,R13, R0
+	BLEU	bout
+	MOVW	-4(R13), R16
+	SUB	$4, R13
+	MOVW	R16, -4(R12)
+	SUB	$4, R12
+	JMP	b5
+
+bout:
+	SUBCC	R11,R13, R0
+	BLEU	ret
+	MOVB	-1(R13), R16
+	SUB	$1, R13
+	MOVB	R16, -1(R12)
+	SUB	$1, R12
+	JMP	bout
+
+ret:
+	MOVW	s1+0(FP), R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/memset.s b/sys/src/ape/lib/ap/sparc/memset.s
new file mode 100755
index 000000000..8c7b26c86
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/memset.s
@@ -0,0 +1,88 @@
+	TEXT	memset(SB),$0
+
+/*
+ * performance:
+ *	(tba)
+ */
+
+MOVW	R7, 0(FP)
+	MOVW	n+8(FP), R9		/* R9 is count */
+	MOVW	p+0(FP), R10		/* R10 is pointer */
+	MOVW	c+4(FP), R11		/* R11 is char */
+	ADD	R9,R10, R12		/* R12 is end pointer */
+
+/*
+ * if not at least 4 chars,
+ * dont even mess around.
+ * 3 chars to guarantee any
+ * rounding up to a word
+ * boundary and 4 characters
+ * to get at least maybe one
+ * full word store.
+ */
+	SUBCC	$4,R9, R0
+	BL	out
+
+/*
+ * turn R11 into a word of characters
+ */
+	AND	$0xff, R11
+	SLL	$8,R11, R7
+	OR	R7, R11
+	SLL	$16,R11, R7
+	OR	R7, R11
+
+/*
+ * store one byte at a time until pointer
+ * is alligned on a word boundary
+ */
+l1:
+	ANDCC	$3,R10, R0
+	BE	l2
+	MOVB	R11, 0(R10)
+	ADD	$1, R10
+	JMP	l1
+
+/*
+ * turn R9 into end pointer-15
+ * store 16 at a time while theres room
+ */
+l2:
+	ADD	$-15,R12, R9
+	SUBCC	R10,R9, R0
+	BLEU	l4
+l3:
+	MOVW	R11, 0(R10)
+	MOVW	R11, 4(R10)
+	ADD	$16, R10
+	SUBCC	R10,R9, R0
+	MOVW	R11, -8(R10)
+	MOVW	R11, -4(R10)
+	BGU	l3
+
+/*
+ * turn R9 into end pointer-3
+ * store 4 at a time while theres room
+ */
+l4:
+	ADD	$-3,R12, R9
+l5:
+	SUBCC	R10,R9, R0
+	BLEU	out
+	MOVW	R11, 0(R10)
+	ADD	$4, R10
+	JMP	l5
+
+/*
+ * last loop, store byte at a time
+ */
+out:
+	SUBCC	R10,R12, R0
+	BLEU	ret
+	MOVB	R11, 0(R10)
+	ADD	$1, R10
+	JMP	out
+
+ret:
+	MOVW	s1+0(FP), R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/mkfile b/sys/src/ape/lib/ap/sparc/mkfile
new file mode 100755
index 000000000..9723ec2c3
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/mkfile
@@ -0,0 +1,26 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	cycles.$O\
+	lock.$O\
+	main9.$O\
+	main9p.$O\
+	memchr.$O\
+	memcmp.$O\
+	memmove.$O\
+	memset.$O\
+	muldiv.$O\
+	notetramp.$O\
+	setjmp.$O\
+	strchr.$O\
+	strcmp.$O\
+	strcpy.$O\
+	tas.$O\
+	vlop.$O\
+	vlrt.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE
+
diff --git a/sys/src/ape/lib/ap/sparc/muldiv.s b/sys/src/ape/lib/ap/sparc/muldiv.s
new file mode 100755
index 000000000..ac811629f
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/muldiv.s
@@ -0,0 +1,310 @@
+/*
+ *	ulong
+ *	_udiv(ulong num, ulong den)
+ *	{
+ *		int i;
+ *		ulong quo;
+ *
+ *		if(den == 0)
+ *			*(ulong*)-1 = 0;
+ *		quo = num;
+ *		if(quo > 1<<(32-1))
+ *			quo = 1<<(32-1);
+ *		for(i=0; den<quo; i++)
+ *			den <<= 1;
+ *		quo = 0;
+ *		for(; i>=0; i--) {
+ *			quo <<= 1;
+ *			if(num >= den) {
+ *				num -= den;
+ *				quo |= 1;
+ *			}
+ *			den >>= 1;
+ *		}
+ *		return quo::num;
+ *	}
+ */
+
+#define	NOPROF	1
+
+/*
+ * calling sequence:
+ *	num: 4(R1)
+ *	den: 8(R1)
+ * returns
+ *	quo: 4(R1)
+ *	rem: 8(R1)
+ */
+TEXT	_udivmod(SB), NOPROF, $-4
+
+	MOVW	$(1<<31), R11
+	MOVW	4(R1), R13	/* numerator */
+	MOVW	8(R1), R10	/* denominator */
+	CMP	R10, R0
+	BNE	udm20
+	MOVW	R0, -1(R0)	/* fault -- divide by zero */
+udm20:
+	MOVW	R13, R12
+	CMP	R13, R11
+	BLEU	udm34
+	MOVW	R11, R12
+udm34:
+	MOVW	R0, R11
+udm38:
+	CMP	R10, R12
+	BCC	udm54
+	SLL	$1, R10
+	ADD	$1, R11
+	BA	udm38
+udm54:
+	MOVW	R0, R12
+udm58:
+	CMP	R11, R0
+	BL	udm8c
+	SLL	$1, R12
+	CMP	R13, R10
+	BCS	udm7c
+	SUB	R10, R13
+	OR	$1, R12
+udm7c:
+	SRL	$1, R10
+	SUB	$1, R11
+	BA	udm58
+udm8c:
+	MOVW	R12, 4(R1)	/* quotent */
+	MOVW	R13, 8(R1)	/* remainder */
+	JMPL	8(R15)
+
+/*
+ * save working registers
+ * and bring in num/den parameters
+ */
+TEXT	_unsarg(SB), NOPROF, $-4
+	MOVW	R10, 12(R1)
+	MOVW	R11, 16(R1)
+	MOVW	R12, 20(R1)
+	MOVW	R13, 24(R1)
+
+	MOVW	R14, 4(R1)
+	MOVW	32(R1), R14
+	MOVW	R14, 8(R1)
+
+	JMPL	8(R15)
+
+/*
+ * save working registers
+ * and bring in absolute value
+ * of num/den parameters
+ */
+TEXT	_absarg(SB), NOPROF, $-4
+	MOVW	R10, 12(R1)
+	MOVW	R11, 16(R1)
+	MOVW	R12, 20(R1)
+	MOVW	R13, 24(R1)
+
+	MOVW	R14, 28(R1)
+	CMP	R14, R0
+	BGE	ab1
+	SUB	R14, R0, R14
+ab1:
+	MOVW	R14, 4(R1)	/* numerator */
+
+	MOVW	32(R1), R14
+	CMP	R14, R0
+	BGE	ab2
+	SUB	R14, R0, R14
+ab2:
+	MOVW	R14, 8(R1)	/* denominator */
+	JMPL	8(R15)
+
+/*
+ * restore registers and
+ * return to original caller
+ * answer is in R14
+ */
+TEXT	_retarg(SB), NOPROF, $-4
+	MOVW	12(R1), R10
+	MOVW	16(R1), R11
+	MOVW	20(R1), R12
+	MOVW	24(R1), R13
+	MOVW	0(R1), R15
+
+	ADD	$28, R1
+	JMP	8(R15)		/* back to main sequence */
+
+/*
+ * calling sequence
+ *	num: R14
+ *	den: 8(R1)
+ * returns
+ *	quo: R14
+ */
+TEXT	_div(SB), NOPROF, $-4
+	SUB	$28, R1		/* 4 reg save, 2 parameters, link */
+	MOVW	R15, 0(R1)
+
+	JMPL	_absarg(SB)
+	JMPL	_udivmod(SB)
+	MOVW	4(R1), R14
+
+	MOVW	28(R1), R10	/* clean up the sign */
+	MOVW	32(R1), R11
+	XORCC	R11, R10, R0
+	BGE	div1
+	SUB	R14, R0, R14
+div1:
+
+	JMPL	_retarg(SB)
+	JMP	8(R15)		/* not executed */
+
+/*
+ * calling sequence
+ *	num: R14
+ *	den: 8(R1)
+ * returns
+ *	quo: R14
+ */
+TEXT	_divl(SB), NOPROF, $-4
+	SUB	$((4+2+1)*4), R1	/* 4 reg save, 2 parameters, link */
+	MOVW	R15, 0(R1)
+
+	JMPL	_unsarg(SB)
+	JMPL	_udivmod(SB)
+	MOVW	4(R1), R14
+
+	JMPL	_retarg(SB)
+	JMP	8(R15)		/* not executed */
+
+/*
+ * calling sequence
+ *	num: R14
+ *	den: 8(R1)
+ * returns
+ *	rem: R14
+ */
+TEXT	_mod(SB), NOPROF, $-4
+	SUB	$28, R1		/* 4 reg save, 2 parameters, link */
+
+	MOVW	R15, 0(R1)
+	JMPL	_absarg(SB)
+	JMPL	_udivmod(SB)
+	MOVW	8(R1), R14
+
+	MOVW	28(R1), R10	/* clean up the sign */
+	CMP	R10, R0
+	BGE	mod1
+	SUB	R14, R0, R14
+mod1:
+
+	JMPL	_retarg(SB)
+	JMP	8(R15)		/* not executed */
+
+/*
+ * calling sequence
+ *	num: R14
+ *	den: 8(R1)
+ * returns
+ *	rem: R14
+ */
+TEXT	_modl(SB), NOPROF, $-4
+	SUB	$28, R1		/* 4 reg save, 2 parameters, link */
+
+
+	MOVW	R15, 0(R1)
+	JMPL	_unsarg(SB)
+	JMPL	_udivmod(SB)
+	MOVW	8(R1), R14
+
+	JMPL	_retarg(SB)
+	JMP	8(R15)		/* not executed */
+
+/*
+ * special calling sequence:
+ *	arg1 in R14
+ *	arg2 in 4(R1),    will save R9
+ *	nothing in 0(R1), will save R8
+ * 	result in R14
+ */
+TEXT	_mul+0(SB), NOPROF, $-4
+
+	/*
+	 * exchange stack and registers
+	 */
+	MOVW	R8, 0(R1)
+	MOVW	4(R1), R8
+	MOVW	R9, 4(R1)
+
+	CMP	R14, R8
+	BLE	mul1
+	MOVW	R14, R9
+	MOVW	R8, R14
+	MOVW	R9, R8
+mul1:
+	MOVW	R14, Y
+	ANDNCC	$0xFFF, R14, R0
+	BE	mul_shortway
+	ANDCC	R0, R0, R9	/* zero partial product and clear N and V cond's */
+
+	/* long multiply */
+	MULSCC	R8, R9, R9		/* 0 */
+	MULSCC	R8, R9, R9		/* 1 */
+	MULSCC	R8, R9, R9		/* 2 */
+	MULSCC	R8, R9, R9		/* 3 */
+	MULSCC	R8, R9, R9		/* 4 */
+	MULSCC	R8, R9, R9		/* 5 */
+	MULSCC	R8, R9, R9		/* 6 */
+	MULSCC	R8, R9, R9		/* 7 */
+	MULSCC	R8, R9, R9		/* 8 */
+	MULSCC	R8, R9, R9		/* 9 */
+	MULSCC	R8, R9, R9		/* 10 */
+	MULSCC	R8, R9, R9		/* 11 */
+	MULSCC	R8, R9, R9		/* 12 */
+	MULSCC	R8, R9, R9		/* 13 */
+	MULSCC	R8, R9, R9		/* 14 */
+	MULSCC	R8, R9, R9		/* 15 */
+	MULSCC	R8, R9, R9		/* 16 */
+	MULSCC	R8, R9, R9		/* 17 */
+	MULSCC	R8, R9, R9		/* 18 */
+	MULSCC	R8, R9, R9		/* 19 */
+	MULSCC	R8, R9, R9		/* 20 */
+	MULSCC	R8, R9, R9		/* 21 */
+	MULSCC	R8, R9, R9		/* 22 */
+	MULSCC	R8, R9, R9		/* 23 */
+	MULSCC	R8, R9, R9		/* 24 */
+	MULSCC	R8, R9, R9		/* 25 */
+	MULSCC	R8, R9, R9		/* 26 */
+	MULSCC	R8, R9, R9		/* 27 */
+	MULSCC	R8, R9, R9		/* 28 */
+	MULSCC	R8, R9, R9		/* 29 */
+	MULSCC	R8, R9, R9		/* 30 */
+	MULSCC	R8, R9, R9		/* 31 */
+	MULSCC	R0, R9, R9		/* 32; shift only */
+
+	MOVW	Y, R14			/* get low part */
+	BA	mul_return
+
+mul_shortway:
+	ANDCC	R0, R0, R9	/* zero partial product and clear N and V cond's */
+	MULSCC	R8, R9, R9		/*  0 */
+	MULSCC	R8, R9, R9		/*  1 */
+	MULSCC	R8, R9, R9		/*  2 */
+	MULSCC	R8, R9, R9		/*  3 */
+	MULSCC	R8, R9, R9		/*  4 */
+	MULSCC	R8, R9, R9		/*  5 */
+	MULSCC	R8, R9, R9		/*  6 */
+	MULSCC	R8, R9, R9		/*  7 */
+	MULSCC	R8, R9, R9		/*  8 */
+	MULSCC	R8, R9, R9		/*  9 */
+	MULSCC	R8, R9, R9		/* 10 */
+	MULSCC	R8, R9, R9		/* 11 */
+	MULSCC	R0, R9, R9		/* 12; shift only */
+
+	MOVW	Y, R8
+	SLL	$12, R9
+	SRL	$20, R8
+	OR	R8, R9, R14
+
+mul_return:
+	MOVW	0(R1), R8
+	MOVW	4(R1), R9
+	JMP	8(R15)
diff --git a/sys/src/ape/lib/ap/sparc/notetramp.c b/sys/src/ape/lib/ap/sparc/notetramp.c
new file mode 100755
index 000000000..c033d62cb
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/notetramp.c
@@ -0,0 +1,81 @@
+#include "../plan9/lib.h"
+#include "../plan9/sys9.h"
+#include <signal.h>
+#include <setjmp.h>
+
+/* A stack to hold pcs when signals nest */
+#define MAXSIGSTACK 20
+typedef struct Pcstack Pcstack;
+static struct Pcstack {
+	int sig;
+	void (*hdlr)(int, char*, Ureg*);
+	unsigned long restorepc;
+	unsigned long restorenpc;
+	Ureg *u;
+} pcstack[MAXSIGSTACK];
+static int nstack = 0;
+
+static void notecont(Ureg*, char*);
+
+void
+_notetramp(int sig, void (*hdlr)(int, char*, Ureg*), Ureg *u)
+{
+	Pcstack *p;
+
+	if(nstack >= MAXSIGSTACK)
+		_NOTED(1);	/* nesting too deep; just do system default */
+	p = &pcstack[nstack];
+	p->restorepc = u->pc;
+	p->restorenpc = u->npc;
+	p->sig = sig;
+	p->hdlr = hdlr;
+	p->u = u;
+	nstack++;
+	u->pc = (unsigned long) notecont;
+	u->npc = u->pc+4;
+	_NOTED(2);	/* NSAVE: clear note but hold state */
+}
+
+static void
+notecont(Ureg *u, char *s)
+{
+	Pcstack *p;
+	void(*f)(int, char*, Ureg*);
+
+	p = &pcstack[nstack-1];
+	f = p->hdlr;
+	u->pc = p->restorepc;
+	u->npc = p->restorenpc;
+	nstack--;
+	(*f)(p->sig, s, u);
+	_NOTED(3);	/* NRSTR */
+}
+
+int	__noterestore(void);
+
+#define JMPBUFPC 1
+#define JMPBUFSP 0
+#define	JMPBUFDPC (-8)
+
+extern sigset_t	_psigblocked;
+
+void
+siglongjmp(sigjmp_buf j, int ret)
+{
+	struct Ureg *u;
+
+	if(j[0])
+		_psigblocked = j[1];
+	if(nstack == 0 || pcstack[nstack-1].u->sp > j[2+JMPBUFSP])
+		longjmp(j+2, ret);
+	u = pcstack[nstack-1].u;
+	nstack--;
+	u->r8 = ret;
+	if(ret == 0)
+		u->r8 = 1;
+	u->r9 = j[JMPBUFPC] - JMPBUFDPC;
+	u->pc = (unsigned long)__noterestore;
+	u->npc = (unsigned long)__noterestore + 4;
+	u->sp = j[JMPBUFSP];
+	_NOTED(3);	/* NRSTR */
+}
diff --git a/sys/src/ape/lib/ap/sparc/setjmp.s b/sys/src/ape/lib/ap/sparc/setjmp.s
new file mode 100755
index 000000000..8194a1d20
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/setjmp.s
@@ -0,0 +1,36 @@
+TEXT	setjmp(SB), 1, $0
+
+	MOVW	R1, (R7)
+	MOVW	R15, 4(R7)
+	MOVW	$0, R7
+	RETURN
+
+TEXT	sigsetjmp(SB), 1, $0
+
+	MOVW	savemask+4(FP), R8
+	MOVW	R8, 0(R7)
+	MOVW	$_psigblocked(SB), R8
+	MOVW	R8, 4(R7)
+	MOVW	R1, 8(R7)
+	MOVW	R15, 12(R7)
+	MOVW	$0, R7
+	RETURN
+
+TEXT	longjmp(SB), 1, $0
+
+	MOVW	R7, R8
+	MOVW	r+4(FP), R7
+	CMP	R7, R0
+	BNE	ok		/* ansi: "longjmp(0) => longjmp(1)" */
+	MOVW	$1, R7		/* bless their pointed heads */
+ok:	MOVW	(R8), R1
+	MOVW	4(R8), R15
+	RETURN
+
+/*
+ * trampoline functions because the kernel smashes r7
+ * in the uregs given to notejmp
+ */
+TEXT	__noterestore(SB), 1, $-4
+	MOVW	R8, R7
+	JMP	(R9)
diff --git a/sys/src/ape/lib/ap/sparc/strchr.s b/sys/src/ape/lib/ap/sparc/strchr.s
new file mode 100755
index 000000000..192beab13
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/strchr.s
@@ -0,0 +1,73 @@
+	TEXT	strchr(SB), $0
+
+MOVW	R7, 0(FP)
+	MOVB	c+7(FP), R10
+	MOVW	s+0(FP), R9
+
+	SUBCC	R0,R10, R0
+	BE	l2
+
+/*
+ * char is not null
+ */
+l1:
+	MOVB	(R9), R7
+	ADD	$1, R9
+	SUBCC	R0,R7, R0
+	BE	ret
+	SUBCC	R7,R10, R0
+	BNE	l1
+	JMP	rm1
+
+/*
+ * char is null
+ * align to word
+ */
+l2:
+	ANDCC	$3,R9, R0
+	BE	l3
+	MOVB	(R9), R7
+	ADD	$1, R9
+	SUBCC	R0,R7, R0
+	BNE	l2
+	JMP	rm1
+
+/*
+ * develop byte masks
+ */
+l3:
+	MOVW	$0xff, R17
+	SLL	$8,R17, R16
+	SLL	$16,R17, R13
+	SLL	$24,R17, R12
+
+l4:
+	MOVW	(R9), R11
+	ADD	$4, R9
+	ANDCC	R12,R11, R0
+	BE	b0
+	ANDCC	R13,R11, R0
+	BE	b1
+	ANDCC	R16,R11, R0
+	BE	b2
+	ANDCC	R17,R11, R0
+	BNE	l4
+
+rm1:
+	SUB	$1,R9, R7
+	JMP	ret
+
+b2:
+	SUB	$2,R9, R7
+	JMP	ret
+
+b1:
+	SUB	$3,R9, R7
+	JMP	ret
+
+b0:
+	SUB	$4,R9, R7
+	JMP	ret
+
+ret:
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/strcmp.s b/sys/src/ape/lib/ap/sparc/strcmp.s
new file mode 100755
index 000000000..e9539ebf8
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/strcmp.s
@@ -0,0 +1,27 @@
+TEXT	strcmp(SB), $0
+
+	MOVW	s2+4(FP), R10
+
+l1:
+	MOVB	0(R7), R8
+	MOVB	0(R10), R9
+	ADD	$1, R7
+	ADD	$1, R10
+
+	CMP	R8, R9
+	BNE	l2
+
+	CMP	R8, $0
+	BNE	l1
+
+	MOVW	R0, R7
+	RETURN
+
+l2:
+	BLEU	l3
+	MOVW	$1, R7
+	RETURN
+
+l3:
+	MOVW	$-1, R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/strcpy.s b/sys/src/ape/lib/ap/sparc/strcpy.s
new file mode 100755
index 000000000..6fd6aef05
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/strcpy.s
@@ -0,0 +1,84 @@
+	TEXT	strcpy(SB), $0
+
+MOVW	R7, 0(FP)
+	MOVW	s1+0(FP), R9		/* R9 is to pointer */
+	MOVW	s2+4(FP), R10		/* R10 is from pointer */
+
+/*
+ * test if both pointers
+ * are similarly word aligned
+ */
+	XOR	R9,R10, R7
+	ANDCC	$3,R7, R0
+	BNE	una
+
+/*
+ * make byte masks
+ */
+	MOVW	$0xff, R17
+	SLL	$8,R17, R16
+	SLL	$16,R17, R13
+	SLL	$24,R17, R12
+
+/*
+ * byte at a time to word align
+ */
+al1:
+	ANDCC	$3,R10, R0
+	BE	al2
+	MOVB	(R10), R11
+	ADD	$1, R10
+	MOVB	R11, (R9)
+	ADD	$1, R9
+	SUBCC	R0,R11, R0
+	BNE	al1
+	JMP	out
+
+/*
+ * word at a time
+ */
+al2:
+	ADD	$4, R9
+	MOVW	(R10), R11	/* fetch */
+	ADD	$4, R10
+	ANDCC	R12,R11, R0	/* is it byte 0 */
+	BE	b0
+	ANDCC	R13,R11, R0	/* is it byte 1 */
+	BE	b1
+	ANDCC	R16,R11, R0	/* is it byte 2 */
+	BE	b2
+	MOVW	R11, -4(R9)	/* store */
+	ANDCC	R17,R11, R0	/* is it byte 3 */
+	BNE	al2
+
+	JMP	out
+
+b0:
+	MOVB	R0, -4(R9)
+	JMP	out
+
+b1:
+	SRL	$24, R11
+	MOVB	R11, -4(R9)
+	MOVB	R0, -3(R9)
+	JMP	out
+
+b2:
+	SRL	$24,R11, R7
+	MOVB	R7, -4(R9)
+	SRL	$16, R11
+	MOVB	R11, -3(R9)
+	MOVB	R0, -2(R9)
+	JMP	out
+
+una:
+	MOVB	(R10), R11
+	ADD	$1, R10
+	MOVB	R11, (R9)
+	ADD	$1, R9
+	SUBCC	R0,R11, R0
+	BNE	una
+
+out:
+	MOVW	s1+0(FP),R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/tas.s b/sys/src/ape/lib/ap/sparc/tas.s
new file mode 100755
index 000000000..70cce835d
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/tas.s
@@ -0,0 +1,7 @@
+/*
+ *	tas uses LDSTUB
+ */
+	TEXT	tas(SB),$-4
+
+	TAS	(R7),R7
+	RETURN
diff --git a/sys/src/ape/lib/ap/sparc/vlop.s b/sys/src/ape/lib/ap/sparc/vlop.s
new file mode 100755
index 000000000..ac36b4143
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/vlop.s
@@ -0,0 +1,112 @@
+TEXT	_mulv(SB), $0
+	MOVW	u1+8(FP), R8
+	MOVW	u2+16(FP), R13
+
+	MOVW	R13, R16		/* save low parts for later */
+	MOVW	R8, R12
+
+	/*
+	 * unsigned 32x32 => 64 multiply
+	 */
+	CMP	R13, R8
+	BLE	mul1
+	MOVW	R12, R13
+	MOVW	R16, R8
+mul1:
+	MOVW	R13, Y
+	ANDNCC	$0xFFF, R13, R0
+	BE	mul_shortway
+	ANDCC	R0, R0, R9		/* zero partial product and clear N and V cond's */
+
+	/* long multiply */
+	MULSCC	R8, R9, R9		/* 0 */
+	MULSCC	R8, R9, R9		/* 1 */
+	MULSCC	R8, R9, R9		/* 2 */
+	MULSCC	R8, R9, R9		/* 3 */
+	MULSCC	R8, R9, R9		/* 4 */
+	MULSCC	R8, R9, R9		/* 5 */
+	MULSCC	R8, R9, R9		/* 6 */
+	MULSCC	R8, R9, R9		/* 7 */
+	MULSCC	R8, R9, R9		/* 8 */
+	MULSCC	R8, R9, R9		/* 9 */
+	MULSCC	R8, R9, R9		/* 10 */
+	MULSCC	R8, R9, R9		/* 11 */
+	MULSCC	R8, R9, R9		/* 12 */
+	MULSCC	R8, R9, R9		/* 13 */
+	MULSCC	R8, R9, R9		/* 14 */
+	MULSCC	R8, R9, R9		/* 15 */
+	MULSCC	R8, R9, R9		/* 16 */
+	MULSCC	R8, R9, R9		/* 17 */
+	MULSCC	R8, R9, R9		/* 18 */
+	MULSCC	R8, R9, R9		/* 19 */
+	MULSCC	R8, R9, R9		/* 20 */
+	MULSCC	R8, R9, R9		/* 21 */
+	MULSCC	R8, R9, R9		/* 22 */
+	MULSCC	R8, R9, R9		/* 23 */
+	MULSCC	R8, R9, R9		/* 24 */
+	MULSCC	R8, R9, R9		/* 25 */
+	MULSCC	R8, R9, R9		/* 26 */
+	MULSCC	R8, R9, R9		/* 27 */
+	MULSCC	R8, R9, R9		/* 28 */
+	MULSCC	R8, R9, R9		/* 29 */
+	MULSCC	R8, R9, R9		/* 30 */
+	MULSCC	R8, R9, R9		/* 31 */
+	MULSCC	R0, R9, R9		/* 32; shift only; r9 is high part */
+
+	/*
+	 * need to correct top word if top bit set
+	 */
+	CMP	R8, R0
+	BGE	mul_tstlow
+	ADD	R13, R9			/* adjust the high parts */
+
+mul_tstlow:
+	MOVW	Y, R13			/* get low part */
+	BA	mul_done
+
+mul_shortway:
+	ANDCC	R0, R0, R9		/* zero partial product and clear N and V cond's */
+	MULSCC	R8, R9, R9		/*  0 */
+	MULSCC	R8, R9, R9		/*  1 */
+	MULSCC	R8, R9, R9		/*  2 */
+	MULSCC	R8, R9, R9		/*  3 */
+	MULSCC	R8, R9, R9		/*  4 */
+	MULSCC	R8, R9, R9		/*  5 */
+	MULSCC	R8, R9, R9		/*  6 */
+	MULSCC	R8, R9, R9		/*  7 */
+	MULSCC	R8, R9, R9		/*  8 */
+	MULSCC	R8, R9, R9		/*  9 */
+	MULSCC	R8, R9, R9		/* 10 */
+	MULSCC	R8, R9, R9		/* 11 */
+	MULSCC	R0, R9, R9		/* 12; shift only; r9 is high part */
+
+	MOVW	Y, R8			/* make low part of partial low part & high part */
+	SLL	$12, R9, R13
+	SRL	$20, R8
+	OR	R8, R13
+
+	SRA	$20, R9			/* high part */
+
+mul_done:
+
+	/*
+	 * mul by high halves if needed
+	 */
+	MOVW	R13, 4(R7)
+	MOVW	u2+12(FP), R11
+	CMP	R11, R0
+	BE	nomul1
+	MUL	R11, R12
+	ADD	R12, R9
+
+nomul1:
+	MOVW	u1+4(FP), R11
+	CMP	R11, R0
+	BE	nomul2
+	MUL	R11, R16
+	ADD	R16, R9
+
+nomul2:
+
+	MOVW	R9, 0(R7)
+	RETURN	
diff --git a/sys/src/ape/lib/ap/sparc/vlrt.c b/sys/src/ape/lib/ap/sparc/vlrt.c
new file mode 100755
index 000000000..6fbd83ca8
--- /dev/null
+++ b/sys/src/ape/lib/ap/sparc/vlrt.c
@@ -0,0 +1,718 @@
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
+
+#define	SIGN(n)	(1UL<<(n-1))
+
+typedef	struct	Vlong	Vlong;
+struct	Vlong
+{
+	union
+	{
+		struct
+		{
+			ulong	hi;
+			ulong	lo;
+		};
+		struct
+		{
+			ushort	hims;
+			ushort	hils;
+			ushort	loms;
+			ushort	lols;
+		};
+	};
+};
+
+void	abort(void);
+
+void
+_addv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo + b.lo;
+	hi = a.hi + b.hi;
+	if(lo < a.lo)
+		hi++;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_subv(Vlong *r, Vlong a, Vlong b)
+{
+	ulong lo, hi;
+
+	lo = a.lo - b.lo;
+	hi = a.hi - b.hi;
+	if(lo > a.lo)
+		hi--;
+	r->lo = lo;
+	r->hi = hi;
+}
+
+void
+_d2v(Vlong *y, double d)
+{
+	union { double d; struct Vlong; } x;
+	ulong xhi, xlo, ylo, yhi;
+	int sh;
+
+	x.d = d;
+
+	xhi = (x.hi & 0xfffff) | 0x100000;
+	xlo = x.lo;
+	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+
+	ylo = 0;
+	yhi = 0;
+	if(sh >= 0) {
+		/* v = (hi||lo) >> sh */
+		if(sh < 32) {
+			if(sh == 0) {
+				ylo = xlo;
+				yhi = xhi;
+			} else {
+				ylo = (xlo >> sh) | (xhi << (32-sh));
+				yhi = xhi >> sh;
+			}
+		} else {
+			if(sh == 32) {
+				ylo = xhi;
+			} else
+			if(sh < 64) {
+				ylo = xhi >> (sh-32);
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh = -sh;
+		if(sh <= 10) {
+			ylo = xlo << sh;
+			yhi = (xhi << sh) | (xlo >> (32-sh));
+		} else {
+			/* overflow */
+			yhi = d;	/* causes something awful */
+		}
+	}
+	if(x.hi & SIGN(32)) {
+		if(ylo != 0) {
+			ylo = -ylo;
+			yhi = ~yhi;
+		} else
+			yhi = -yhi;
+	}
+
+	y->hi = yhi;
+	y->lo = ylo;
+}
+
+void
+_f2v(Vlong *y, float f)
+{
+
+	_d2v(y, f);
+}
+
+double
+_v2d(Vlong x)
+{
+	if(x.hi & SIGN(32)) {
+		if(x.lo) {
+			x.lo = -x.lo;
+			x.hi = ~x.hi;
+		} else
+			x.hi = -x.hi;
+		return -((long)x.hi*4294967296. + x.lo);
+	}
+	return (long)x.hi*4294967296. + x.lo;
+}
+
+float
+_v2f(Vlong x)
+{
+	return _v2d(x);
+}
+
+static void
+dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
+{
+	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
+	int i;
+
+	numhi = num.hi;
+	numlo = num.lo;
+	denhi = den.hi;
+	denlo = den.lo;
+
+	/*
+	 * get a divide by zero
+	 */
+	if(denlo==0 && denhi==0) {
+		numlo = numlo / denlo;
+	}
+
+	/*
+	 * set up the divisor and find the number of iterations needed
+	 */
+	if(numhi >= SIGN(32)) {
+		quohi = SIGN(32);
+		quolo = 0;
+	} else {
+		quohi = numhi;
+		quolo = numlo;
+	}
+	i = 0;
+	while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
+		denhi = (denhi<<1) | (denlo>>31);
+		denlo <<= 1;
+		i++;
+	}
+
+	quohi = 0;
+	quolo = 0;
+	for(; i >= 0; i--) {
+		quohi = (quohi<<1) | (quolo>>31);
+		quolo <<= 1;
+		if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
+			t = numlo;
+			numlo -= denlo;
+			if(numlo > t)
+				numhi--;
+			numhi -= denhi;
+			quolo |= 1;
+		}
+		denlo = (denlo>>1) | (denhi<<31);
+		denhi >>= 1;
+	}
+
+	if(q) {
+		q->lo = quolo;
+		q->hi = quohi;
+	}
+	if(r) {
+		r->lo = numlo;
+		r->hi = numhi;
+	}
+}
+
+void
+_divvu(Vlong *q, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		q->hi = 0;
+		q->lo = n.lo / d.lo;
+		return;
+	}
+	dodiv(n, d, q, 0);
+}
+
+void
+_modvu(Vlong *r, Vlong n, Vlong d)
+{
+
+	if(n.hi == 0 && d.hi == 0) {
+		r->hi = 0;
+		r->lo = n.lo % d.lo;
+		return;
+	}
+	dodiv(n, d, 0, r);
+}
+
+static void
+vneg(Vlong *v)
+{
+
+	if(v->lo == 0) {
+		v->hi = -v->hi;
+		return;
+	}
+	v->lo = -v->lo;
+	v->hi = ~v->hi;
+}
+
+void
+_divv(Vlong *q, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		q->lo = (long)n.lo / (long)d.lo;
+		q->hi = ((long)q->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, q, 0);
+	if(nneg != dneg)
+		vneg(q);
+}
+
+void
+_modv(Vlong *r, Vlong n, Vlong d)
+{
+	long nneg, dneg;
+
+	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
+		r->lo = (long)n.lo % (long)d.lo;
+		r->hi = ((long)r->lo) >> 31;
+		return;
+	}
+	nneg = n.hi >> 31;
+	if(nneg)
+		vneg(&n);
+	dneg = d.hi >> 31;
+	if(dneg)
+		vneg(&d);
+	dodiv(n, d, 0, r);
+	if(nneg)
+		vneg(r);
+}
+
+void
+_rshav(Vlong *r, Vlong a, int b)
+{
+	long t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = t>>31;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = t>>31;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_rshlv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.hi;
+	if(b >= 32) {
+		r->hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->lo = 0;
+			return;
+		}
+		r->lo = t >> (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->hi = t;
+		r->lo = a.lo;
+		return;
+	}
+	r->hi = t >> b;
+	r->lo = (t << (32-b)) | (a.lo >> b);
+}
+
+void
+_lshv(Vlong *r, Vlong a, int b)
+{
+	ulong t;
+
+	t = a.lo;
+	if(b >= 32) {
+		r->lo = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r->hi = 0;
+			return;
+		}
+		r->hi = t << (b-32);
+		return;
+	}
+	if(b <= 0) {
+		r->lo = t;
+		r->hi = a.hi;
+		return;
+	}
+	r->lo = t << b;
+	r->hi = (t >> (32-b)) | (a.hi << b);
+}
+
+void
+_andv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi & b.hi;
+	r->lo = a.lo & b.lo;
+}
+
+void
+_orv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi | b.hi;
+	r->lo = a.lo | b.lo;
+}
+
+void
+_xorv(Vlong *r, Vlong a, Vlong b)
+{
+	r->hi = a.hi ^ b.hi;
+	r->lo = a.lo ^ b.lo;
+}
+
+void
+_vpp(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+}
+
+void
+_vmm(Vlong *l, Vlong *r)
+{
+
+	l->hi = r->hi;
+	l->lo = r->lo;
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+}
+
+void
+_ppv(Vlong *l, Vlong *r)
+{
+
+	r->lo++;
+	if(r->lo == 0)
+		r->hi++;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_mmv(Vlong *l, Vlong *r)
+{
+
+	if(r->lo == 0)
+		r->hi--;
+	r->lo--;
+	l->hi = r->hi;
+	l->lo = r->lo;
+}
+
+void
+_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+{
+	Vlong t, u;
+
+	u = *ret;
+	switch(type) {
+	default:
+		abort();
+		break;
+
+	case 1:	/* schar */
+		t.lo = *(schar*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(schar*)lv = u.lo;
+		break;
+
+	case 2:	/* uchar */
+		t.lo = *(uchar*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uchar*)lv = u.lo;
+		break;
+
+	case 3:	/* short */
+		t.lo = *(short*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(short*)lv = u.lo;
+		break;
+
+	case 4:	/* ushort */
+		t.lo = *(ushort*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ushort*)lv = u.lo;
+		break;
+
+	case 9:	/* int */
+		t.lo = *(int*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(int*)lv = u.lo;
+		break;
+
+	case 10:	/* uint */
+		t.lo = *(uint*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(uint*)lv = u.lo;
+		break;
+
+	case 5:	/* long */
+		t.lo = *(long*)lv;
+		t.hi = t.lo >> 31;
+		fn(&u, t, rv);
+		*(long*)lv = u.lo;
+		break;
+
+	case 6:	/* ulong */
+		t.lo = *(ulong*)lv;
+		t.hi = 0;
+		fn(&u, t, rv);
+		*(ulong*)lv = u.lo;
+		break;
+
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		fn(&u, *(Vlong*)lv, rv);
+		*(Vlong*)lv = u;
+		break;
+	}
+	*ret = u;
+}
+
+void
+_p2v(Vlong *ret, void *p)
+{
+	long t;
+
+	t = (ulong)p;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sl2v(Vlong *ret, long sl)
+{
+	long t;
+
+	t = sl;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ul2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_si2v(Vlong *ret, int si)
+{
+	long t;
+
+	t = si;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_ui2v(Vlong *ret, uint ui)
+{
+	long t;
+
+	t = ui;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sh2v(Vlong *ret, long sh)
+{
+	long t;
+
+	t = (sh << 16) >> 16;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uh2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xffff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+void
+_sc2v(Vlong *ret, long uc)
+{
+	long t;
+
+	t = (uc << 24) >> 24;
+	ret->lo = t;
+	ret->hi = t >> 31;
+}
+
+void
+_uc2v(Vlong *ret, ulong ul)
+{
+	long t;
+
+	t = ul & 0xff;
+	ret->lo = t;
+	ret->hi = 0;
+}
+
+long
+_v2sc(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xff;
+	return (t << 24) >> 24;
+}
+
+long
+_v2uc(Vlong rv)
+{
+
+	return rv.lo & 0xff;
+}
+
+long
+_v2sh(Vlong rv)
+{
+	long t;
+
+	t = rv.lo & 0xffff;
+	return (t << 16) >> 16;
+}
+
+long
+_v2uh(Vlong rv)
+{
+
+	return rv.lo & 0xffff;
+}
+
+long
+_v2sl(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ul(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2si(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+long
+_v2ui(Vlong rv)
+{
+
+	return rv.lo;
+}
+
+int
+_testv(Vlong rv)
+{
+	return rv.lo || rv.hi;
+}
+
+int
+_eqv(Vlong lv, Vlong rv)
+{
+	return lv.lo == rv.lo && lv.hi == rv.hi;
+}
+
+int
+_nev(Vlong lv, Vlong rv)
+{
+	return lv.lo != rv.lo || lv.hi != rv.hi;
+}
+
+int
+_ltv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi < (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_gtv(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_gev(Vlong lv, Vlong rv)
+{
+	return (long)lv.hi > (long)rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
+
+int
+_lov(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo < rv.lo);
+}
+
+int
+_lsv(Vlong lv, Vlong rv)
+{
+	return lv.hi < rv.hi || 
+		(lv.hi == rv.hi && lv.lo <= rv.lo);
+}
+
+int
+_hiv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo > rv.lo);
+}
+
+int
+_hsv(Vlong lv, Vlong rv)
+{
+	return lv.hi > rv.hi || 
+		(lv.hi == rv.hi && lv.lo >= rv.lo);
+}
diff --git a/sys/src/ape/lib/ap/stdio/_IO_getc.c b/sys/src/ape/lib/ap/stdio/_IO_getc.c
new file mode 100755
index 000000000..3f99922c2
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/_IO_getc.c
@@ -0,0 +1,30 @@
+/*
+ * pANS stdio -- _IO_getc
+ */
+#include "iolib.h"
+int _IO_getc(FILE *f){
+	int cnt, n;
+	switch(f->state){
+	default:	/* CLOSED, WR, ERR, EOF */
+		return EOF;
+	case OPEN:
+		_IO_setvbuf(f);
+	case RDWR:
+	case RD:
+		if(f->flags&STRING) return EOF;
+		if(f->buf == f->unbuf)
+			n = 1;
+		else
+			n = f->bufl;
+		cnt=read(f->fd, f->buf, n);
+		switch(cnt){
+		case -1: f->state=ERR; return EOF;
+		case 0: f->state=END; return EOF;
+		default:
+			f->state=RD;
+			f->rp=f->buf;
+			f->wp=f->buf+cnt;
+			return (*f->rp++)&_IO_CHMASK;
+		}
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/_IO_putc.c b/sys/src/ape/lib/ap/stdio/_IO_putc.c
new file mode 100755
index 000000000..8cef77fd3
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/_IO_putc.c
@@ -0,0 +1,106 @@
+/*
+ * pANS stdio -- _IO_putc, _IO_cleanup
+ */
+#include "iolib.h"
+
+void _IO_cleanup(void){
+	fflush(NULL);
+}
+/*
+ * Look this over for simplification
+ */
+int _IO_putc(int c, FILE *f){
+	int cnt;
+	static int first=1;
+	switch(f->state){
+	case RD:
+		f->state=ERR;
+	case ERR:
+	case CLOSED:
+		return EOF;
+	case OPEN:
+		_IO_setvbuf(f);
+		/* fall through */
+	case RDWR:
+	case END:
+		f->rp=f->buf+f->bufl;
+		if(f->flags&LINEBUF){
+			f->wp=f->rp;
+			f->lp=f->buf;
+		}
+		else
+			f->wp=f->buf;
+		break;
+	}
+	if(first){
+		atexit(_IO_cleanup);
+		first=0;
+	}
+	if(f->flags&STRING){
+		f->rp=f->buf+f->bufl;
+		if(f->wp==f->rp){
+			if(f->flags&BALLOC)
+				f->buf=realloc(f->buf, f->bufl+BUFSIZ);
+			else{
+				f->state=ERR;
+				return EOF;
+			}
+			if(f->buf==NULL){
+				f->state=ERR;
+				return EOF;
+			}
+			f->rp=f->buf+f->bufl;
+			f->bufl+=BUFSIZ;
+		}
+		*f->wp++=c;
+	}
+	else if(f->flags&LINEBUF){
+		if(f->lp==f->rp){
+			cnt=f->lp-f->buf;
+			if(f->flags&APPEND) lseek(f->fd, 0L, SEEK_END);
+			if(cnt!=0 && write(f->fd, f->buf, cnt)!=cnt){
+				f->state=ERR;
+				return EOF;
+			}
+			f->lp=f->buf;
+		}
+		*f->lp++=c;
+		if(c=='\n'){
+			cnt=f->lp-f->buf;
+			if(f->flags&APPEND) lseek(f->fd, 0L, SEEK_END);
+			if(cnt!=0 && write(f->fd, f->buf, cnt)!=cnt){
+				f->state=ERR;
+				return EOF;
+			}
+			f->lp=f->buf;
+		}
+	}
+	else if(f->buf==f->unbuf){
+		f->unbuf[0]=c;
+		if(f->flags&APPEND) lseek(f->fd, 0L, SEEK_END);
+		if(write(f->fd, f->buf, 1)!=1){
+			f->state=ERR;
+			return EOF;
+		}
+	}
+	else{
+		if(f->wp==f->rp){
+			cnt=f->wp-f->buf;
+			if(f->flags&APPEND) lseek(f->fd, 0L, SEEK_END);
+			if(cnt!=0 && write(f->fd, f->buf, cnt)!=cnt){
+				f->state=ERR;
+				return EOF;
+			}
+			f->wp=f->buf;
+			f->rp=f->buf+f->bufl;
+		}
+		*f->wp++=c;
+	}
+	f->state=WR;
+	/*
+	 * Make sure EOF looks different from putc(-1)
+	 * Should be able to cast to unsigned char, but
+	 * there's a vc bug preventing that from working
+	 */
+	return c&0xff;
+}
diff --git a/sys/src/ape/lib/ap/stdio/_dtoa.c b/sys/src/ape/lib/ap/stdio/_dtoa.c
new file mode 100755
index 000000000..fe147789b
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/_dtoa.c
@@ -0,0 +1,744 @@
+#include "fconv.h"
+
+static int quorem(Bigint *, Bigint *);
+
+/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
+ *
+ * Inspired by "How to Print Floating-Point Numbers Accurately" by
+ * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *	1. Rather than iterating, we use a simple numeric overestimate
+ *	   to determine k = floor(log10(d)).  We scale relevant
+ *	   quantities using O(log2(k)) rather than O(k) multiplications.
+ *	2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
+ *	   try to generate digits strictly left to right.  Instead, we
+ *	   compute with fewer bits and propagate the carry if necessary
+ *	   when rounding the final digit up.  This is often faster.
+ *	3. Under the assumption that input will be rounded nearest,
+ *	   mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
+ *	   That is, we allow equality in stopping tests when the
+ *	   round-nearest rule will give the same floating-point value
+ *	   as would satisfaction of the stopping test with strict
+ *	   inequality.
+ *	4. We remove common factors of powers of 2 from relevant
+ *	   quantities.
+ *	5. When converting floating-point integers less than 1e16,
+ *	   we use floating-point arithmetic rather than resorting
+ *	   to multiple-precision integers.
+ *	6. When asked to produce fewer than 15 digits, we first try
+ *	   to get by with floating-point arithmetic; we resort to
+ *	   multiple-precision integer arithmetic only if we cannot
+ *	   guarantee that the floating-point calculation has given
+ *	   the correctly rounded result.  For k requested digits and
+ *	   "uniformly" distributed input, the probability is
+ *	   something like 10^(k-15) that we must resort to the long
+ *	   calculation.
+ */
+
+ char *
+_dtoa(double darg, int mode, int ndigits, int *decpt, int *sign, char **rve)
+{
+ /*	Arguments ndigits, decpt, sign are similar to those
+	of ecvt and fcvt; trailing zeros are suppressed from
+	the returned string.  If not null, *rve is set to point
+	to the end of the return value.  If d is +-Infinity or NaN,
+	then *decpt is set to 9999.
+
+	mode:
+		0 ==> shortest string that yields d when read in
+			and rounded to nearest.
+		1 ==> like 0, but with Steele & White stopping rule;
+			e.g. with IEEE P754 arithmetic , mode 0 gives
+			1e23 whereas mode 1 gives 9.999999999999999e22.
+		2 ==> max(1,ndigits) significant digits.  This gives a
+			return value similar to that of ecvt, except
+			that trailing zeros are suppressed.
+		3 ==> through ndigits past the decimal point.  This
+			gives a return value similar to that from fcvt,
+			except that trailing zeros are suppressed, and
+			ndigits can be negative.
+		4-9 should give the same return values as 2-3, i.e.,
+			4 <= mode <= 9 ==> same return as mode
+			2 + (mode & 1).  These modes are mainly for
+			debugging; often they run slower but sometimes
+			faster than modes 2-3.
+		4,5,8,9 ==> left-to-right digit generation.
+		6-9 ==> don't try fast floating-point estimate
+			(if applicable).
+
+		Values of mode other than 0-9 are treated as mode 0.
+
+		Sufficient space is allocated to the return value
+		to hold the suppressed trailing zeros.
+	*/
+
+	int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
+		j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
+		spec_case, try_quick;
+	long L;
+#ifndef Sudden_Underflow
+	int denorm;
+	unsigned long x;
+#endif
+	Bigint *b, *b1, *delta, *mlo, *mhi, *S;
+	double ds;
+	Dul d2, eps;
+	char *s, *s0;
+	static Bigint *result;
+	static int result_k;
+	Dul d;
+
+	d.d = darg;
+	if (result) {
+		result->k = result_k;
+		result->maxwds = 1 << result_k;
+		Bfree(result);
+		result = 0;
+		}
+
+	if (word0(d) & Sign_bit) {
+		/* set sign for everything, including 0's and NaNs */
+		*sign = 1;
+		word0(d) &= ~Sign_bit;	/* clear sign bit */
+		}
+	else
+		*sign = 0;
+
+#if defined(IEEE_Arith) + defined(VAX)
+#ifdef IEEE_Arith
+	if ((word0(d) & Exp_mask) == Exp_mask)
+#else
+	if (word0(d)  == 0x8000)
+#endif
+		{
+		/* Infinity or NaN */
+		*decpt = 9999;
+		s =
+#ifdef IEEE_Arith
+			!word1(d) && !(word0(d) & 0xfffff) ? "Infinity" :
+#endif
+				"NaN";
+		if (rve)
+			*rve =
+#ifdef IEEE_Arith
+				s[3] ? s + 8 :
+#endif
+						s + 3;
+		return s;
+		}
+#endif
+#ifdef IBM
+	d.d += 0; /* normalize */
+#endif
+	if (!d.d) {
+		*decpt = 1;
+		s = "0";
+		if (rve)
+			*rve = s + 1;
+		return s;
+		}
+
+	b = d2b(d.d, &be, &bbits);
+#ifdef Sudden_Underflow
+	i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
+#else
+	if (i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) {
+#endif
+		d2.d = d.d;
+		word0(d2) &= Frac_mask1;
+		word0(d2) |= Exp_11;
+#ifdef IBM
+		if (j = 11 - hi0bits(word0(d2) & Frac_mask))
+			d2.d /= 1 << j;
+#endif
+
+		/* log(x)	~=~ log(1.5) + (x-1.5)/1.5
+		 * log10(x)	 =  log(x) / log(10)
+		 *		~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
+		 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+		 *
+		 * This suggests computing an approximation k to log10(d) by
+		 *
+		 * k = (i - Bias)*0.301029995663981
+		 *	+ ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
+		 *
+		 * We want k to be too large rather than too small.
+		 * The error in the first-order Taylor series approximation
+		 * is in our favor, so we just round up the constant enough
+		 * to compensate for any error in the multiplication of
+		 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
+		 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
+		 * adding 1e-13 to the constant term more than suffices.
+		 * Hence we adjust the constant term to 0.1760912590558.
+		 * (We could get a more accurate k by invoking log10,
+		 *  but this is probably not worthwhile.)
+		 */
+
+		i -= Bias;
+#ifdef IBM
+		i <<= 2;
+		i += j;
+#endif
+#ifndef Sudden_Underflow
+		denorm = 0;
+		}
+	else {
+		/* d is denormalized */
+
+		i = bbits + be + (Bias + (P-1) - 1);
+		x = i > 32  ? word0(d) << 64 - i | word1(d) >> i - 32
+			    : word1(d) << 32 - i;
+		d2.d = x;
+		word0(d2) -= 31*Exp_msk1; /* adjust exponent */
+		i -= (Bias + (P-1) - 1) + 1;
+		denorm = 1;
+		}
+#endif
+	ds = (d2.d-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+	k = floor(ds);
+	k_check = 1;
+	if (k >= 0 && k <= Ten_pmax) {
+		if (d.d < tens[k])
+			k--;
+		k_check = 0;
+		}
+	j = bbits - i - 1;
+	if (j >= 0) {
+		b2 = 0;
+		s2 = j;
+		}
+	else {
+		b2 = -j;
+		s2 = 0;
+		}
+	if (k >= 0) {
+		b5 = 0;
+		s5 = k;
+		s2 += k;
+		}
+	else {
+		b2 -= k;
+		b5 = -k;
+		s5 = 0;
+		}
+	if (mode < 0 || mode > 9)
+		mode = 0;
+	try_quick = 1;
+	if (mode > 5) {
+		mode -= 4;
+		try_quick = 0;
+		}
+	leftright = 1;
+	switch(mode) {
+		case 0:
+		case 1:
+			ilim = ilim1 = -1;
+			i = 18;
+			ndigits = 0;
+			break;
+		case 2:
+			leftright = 0;
+			/* no break */
+		case 4:
+			if (ndigits <= 0)
+				ndigits = 1;
+			ilim = ilim1 = i = ndigits;
+			break;
+		case 3:
+			leftright = 0;
+			/* no break */
+		case 5:
+			i = ndigits + k + 1;
+			ilim = i;
+			ilim1 = i - 1;
+			if (i <= 0)
+				i = 1;
+		}
+	j = sizeof(unsigned long);
+	for(result_k = 0; sizeof(Bigint) - sizeof(unsigned long) + j <= i;
+		j <<= 1) result_k++;
+	result = Balloc(result_k);
+	s = s0 = (char *)result;
+
+	if (ilim >= 0 && ilim <= Quick_max && try_quick) {
+	
+		/* Try to get by with floating-point arithmetic. */
+	
+		i = 0;
+		d2.d = d.d;
+		k0 = k;
+		ilim0 = ilim;
+		ieps = 2; /* conservative */
+		if (k > 0) {
+			ds = tens[k&0xf];
+			j = k >> 4;
+			if (j & Bletch) {
+				/* prevent overflows */
+				j &= Bletch - 1;
+				d.d /= bigtens[n_bigtens-1];
+				ieps++;
+				}
+			for(; j; j >>= 1, i++)
+				if (j & 1) {
+					ieps++;
+					ds *= bigtens[i];
+					}
+			d.d /= ds;
+			}
+		else if (j1 = -k) {
+			d.d *= tens[j1 & 0xf];
+			for(j = j1 >> 4; j; j >>= 1, i++)
+				if (j & 1) {
+					ieps++;
+					d.d *= bigtens[i];
+					}
+			}
+		if (k_check && d.d < 1. && ilim > 0) {
+			if (ilim1 <= 0)
+				goto fast_failed;
+			ilim = ilim1;
+			k--;
+			d.d *= 10.;
+			ieps++;
+			}
+		eps.d = ieps*d.d + 7.;
+		word0(eps) -= (P-1)*Exp_msk1;
+		if (ilim == 0) {
+			S = mhi = 0;
+			d.d -= 5.;
+			if (d.d > eps.d)
+				goto one_digit;
+			if (d.d < -eps.d)
+				goto no_digits;
+			goto fast_failed;
+			}
+#ifndef No_leftright
+		if (leftright) {
+			/* Use Steele & White method of only
+			 * generating digits needed.
+			 */
+			eps.d = 0.5/tens[ilim-1] - eps.d;
+			for(i = 0;;) {
+				L = floor(d.d);
+				d.d -= L;
+				*s++ = '0' + (int)L;
+				if (d.d < eps.d)
+					goto ret1;
+				if (1. - d.d < eps.d)
+					goto bump_up;
+				if (++i >= ilim)
+					break;
+				eps.d *= 10.;
+				d.d *= 10.;
+				}
+			}
+		else {
+#endif
+			/* Generate ilim digits, then fix them up. */
+			eps.d *= tens[ilim-1];
+			for(i = 1;; i++, d.d *= 10.) {
+				L = floor(d.d);
+				d.d -= L;
+				*s++ = '0' + (int)L;
+				if (i == ilim) {
+					if (d.d > 0.5 + eps.d)
+						goto bump_up;
+					else if (d.d < 0.5 - eps.d) {
+						while(*--s == '0');
+						s++;
+						goto ret1;
+						}
+					break;
+					}
+				}
+#ifndef No_leftright
+			}
+#endif
+ fast_failed:
+		s = s0;
+		d.d = d2.d;
+		k = k0;
+		ilim = ilim0;
+		}
+
+	/* Do we have a "small" integer? */
+
+	if (be >= 0 && k <= Int_max) {
+		/* Yes. */
+		ds = tens[k];
+		if (ndigits < 0 && ilim <= 0) {
+			S = mhi = 0;
+			if (ilim < 0 || d.d <= 5*ds)
+				goto no_digits;
+			goto one_digit;
+			}
+		for(i = 1;; i++) {
+			L = floor(d.d / ds);
+			d.d -= L*ds;
+#ifdef Check_FLT_ROUNDS
+			/* If FLT_ROUNDS == 2, L will usually be high by 1 */
+			if (d.d < 0) {
+				L--;
+				d.d += ds;
+				}
+#endif
+			*s++ = '0' + (int)L;
+			if (i == ilim) {
+				d.d += d.d;
+				if (d.d > ds || d.d == ds && L & 1) {
+ bump_up:
+					while(*--s == '9')
+						if (s == s0) {
+							k++;
+							*s = '0';
+							break;
+							}
+					++*s++;
+					}
+				break;
+				}
+			d.d *= 10.;
+			if (d.d == 0.)
+				break;
+			}
+		goto ret1;
+		}
+
+	m2 = b2;
+	m5 = b5;
+	mhi = mlo = 0;
+	if (leftright) {
+		if (mode < 2) {
+			i =
+#ifndef Sudden_Underflow
+				denorm ? be + (Bias + (P-1) - 1 + 1) :
+#endif
+#ifdef IBM
+				1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3);
+#else
+				1 + P - bbits;
+#endif
+			}
+		else {
+			j = ilim - 1;
+			if (m5 >= j)
+				m5 -= j;
+			else {
+				s5 += j -= m5;
+				b5 += j;
+				m5 = 0;
+				}
+			if ((i = ilim) < 0) {
+				m2 -= i;
+				i = 0;
+				}
+			}
+		b2 += i;
+		s2 += i;
+		mhi = i2b(1);
+		}
+	if (m2 > 0 && s2 > 0) {
+		i = m2 < s2 ? m2 : s2;
+		b2 -= i;
+		m2 -= i;
+		s2 -= i;
+		}
+	if (b5 > 0) {
+		if (leftright) {
+			if (m5 > 0) {
+				mhi = pow5mult(mhi, m5);
+				b1 = mult(mhi, b);
+				Bfree(b);
+				b = b1;
+				}
+			if (j = b5 - m5)
+				b = pow5mult(b, j);
+			}
+		else
+			b = pow5mult(b, b5);
+		}
+	S = i2b(1);
+	if (s5 > 0)
+		S = pow5mult(S, s5);
+
+	/* Check for special case that d is a normalized power of 2. */
+
+	if (mode < 2) {
+		if (!word1(d) && !(word0(d) & Bndry_mask)
+#ifndef Sudden_Underflow
+		 && word0(d) & Exp_mask
+#endif
+				) {
+			/* The special case */
+			b2 += Log2P;
+			s2 += Log2P;
+			spec_case = 1;
+			}
+		else
+			spec_case = 0;
+		}
+
+	/* Arrange for convenient computation of quotients:
+	 * shift left if necessary so divisor has 4 leading 0 bits.
+	 *
+	 * Perhaps we should just compute leading 28 bits of S once
+	 * and for all and pass them and a shift to quorem, so it
+	 * can do shifts and ors to compute the numerator for q.
+	 */
+#ifdef Pack_32
+	if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f)
+		i = 32 - i;
+#else
+	if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf)
+		i = 16 - i;
+#endif
+	if (i > 4) {
+		i -= 4;
+		b2 += i;
+		m2 += i;
+		s2 += i;
+		}
+	else if (i < 4) {
+		i += 28;
+		b2 += i;
+		m2 += i;
+		s2 += i;
+		}
+	if (b2 > 0)
+		b = lshift(b, b2);
+	if (s2 > 0)
+		S = lshift(S, s2);
+	if (k_check) {
+		if (cmp(b,S) < 0) {
+			k--;
+			b = multadd(b, 10, 0);	/* we botched the k estimate */
+			if (leftright)
+				mhi = multadd(mhi, 10, 0);
+			ilim = ilim1;
+			}
+		}
+	if (ilim <= 0 && mode > 2) {
+		if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
+			/* no digits, fcvt style */
+ no_digits:
+			k = -1 - ndigits;
+			goto ret;
+			}
+ one_digit:
+		*s++ = '1';
+		k++;
+		goto ret;
+		}
+	if (leftright) {
+		if (m2 > 0)
+			mhi = lshift(mhi, m2);
+
+		/* Compute mlo -- check for special case
+		 * that d is a normalized power of 2.
+		 */
+
+		mlo = mhi;
+		if (spec_case) {
+			mhi = Balloc(mhi->k);
+			Bcopy(mhi, mlo);
+			mhi = lshift(mhi, Log2P);
+			}
+
+		for(i = 1;;i++) {
+			dig = quorem(b,S) + '0';
+			/* Do we yet have the shortest decimal string
+			 * that will round to d?
+			 */
+			j = cmp(b, mlo);
+			delta = diff(S, mhi);
+			j1 = delta->sign ? 1 : cmp(b, delta);
+			Bfree(delta);
+#ifndef ROUND_BIASED
+			if (j1 == 0 && !mode && !(word1(d) & 1)) {
+				if (dig == '9')
+					goto round_9_up;
+				if (j > 0)
+					dig++;
+				*s++ = dig;
+				goto ret;
+				}
+#endif
+			if (j < 0 || j == 0 && !mode
+#ifndef ROUND_BIASED
+							&& !(word1(d) & 1)
+#endif
+					) {
+				if (j1 > 0) {
+					b = lshift(b, 1);
+					j1 = cmp(b, S);
+					if ((j1 > 0 || j1 == 0 && dig & 1)
+					&& dig++ == '9')
+						goto round_9_up;
+					}
+				*s++ = dig;
+				goto ret;
+				}
+			if (j1 > 0) {
+				if (dig == '9') { /* possible if i == 1 */
+ round_9_up:
+					*s++ = '9';
+					goto roundoff;
+					}
+				*s++ = dig + 1;
+				goto ret;
+				}
+			*s++ = dig;
+			if (i == ilim)
+				break;
+			b = multadd(b, 10, 0);
+			if (mlo == mhi)
+				mlo = mhi = multadd(mhi, 10, 0);
+			else {
+				mlo = multadd(mlo, 10, 0);
+				mhi = multadd(mhi, 10, 0);
+				}
+			}
+		}
+	else
+		for(i = 1;; i++) {
+			*s++ = dig = quorem(b,S) + '0';
+			if (i >= ilim)
+				break;
+			b = multadd(b, 10, 0);
+			}
+
+	/* Round off last digit */
+
+	b = lshift(b, 1);
+	j = cmp(b, S);
+	if (j > 0 || j == 0 && dig & 1) {
+ roundoff:
+		while(*--s == '9')
+			if (s == s0) {
+				k++;
+				*s++ = '1';
+				goto ret;
+				}
+		++*s++;
+		}
+	else {
+		while(*--s == '0');
+		s++;
+		}
+ ret:
+	Bfree(S);
+	if (mhi) {
+		if (mlo && mlo != mhi)
+			Bfree(mlo);
+		Bfree(mhi);
+		}
+ ret1:
+	Bfree(b);
+	*s = 0;
+	*decpt = k + 1;
+	if (rve)
+		*rve = s;
+	return s0;
+	}
+
+ static int
+quorem(Bigint *b, Bigint *S)
+{
+	int n;
+	long borrow, y;
+	unsigned long carry, q, ys;
+	unsigned long *bx, *bxe, *sx, *sxe;
+#ifdef Pack_32
+	long z;
+	unsigned long si, zs;
+#endif
+
+	n = S->wds;
+#ifdef DEBUG
+	/*debug*/ if (b->wds > n)
+	/*debug*/	Bug("oversize b in quorem");
+#endif
+	if (b->wds < n)
+		return 0;
+	sx = S->x;
+	sxe = sx + --n;
+	bx = b->x;
+	bxe = bx + n;
+	q = *bxe / (*sxe + 1);	/* ensure q <= true quotient */
+#ifdef DEBUG
+	/*debug*/ if (q > 9)
+	/*debug*/	Bug("oversized quotient in quorem");
+#endif
+	if (q) {
+		borrow = 0;
+		carry = 0;
+		do {
+#ifdef Pack_32
+			si = *sx++;
+			ys = (si & 0xffff) * q + carry;
+			zs = (si >> 16) * q + (ys >> 16);
+			carry = zs >> 16;
+			y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+			borrow = y >> 16;
+			Sign_Extend(borrow, y);
+			z = (*bx >> 16) - (zs & 0xffff) + borrow;
+			borrow = z >> 16;
+			Sign_Extend(borrow, z);
+			Storeinc(bx, z, y);
+#else
+			ys = *sx++ * q + carry;
+			carry = ys >> 16;
+			y = *bx - (ys & 0xffff) + borrow;
+			borrow = y >> 16;
+			Sign_Extend(borrow, y);
+			*bx++ = y & 0xffff;
+#endif
+			}
+			while(sx <= sxe);
+		if (!*bxe) {
+			bx = b->x;
+			while(--bxe > bx && !*bxe)
+				--n;
+			b->wds = n;
+			}
+		}
+	if (cmp(b, S) >= 0) {
+		q++;
+		borrow = 0;
+		carry = 0;
+		bx = b->x;
+		sx = S->x;
+		do {
+#ifdef Pack_32
+			si = *sx++;
+			ys = (si & 0xffff) + carry;
+			zs = (si >> 16) + (ys >> 16);
+			carry = zs >> 16;
+			y = (*bx & 0xffff) - (ys & 0xffff) + borrow;
+			borrow = y >> 16;
+			Sign_Extend(borrow, y);
+			z = (*bx >> 16) - (zs & 0xffff) + borrow;
+			borrow = z >> 16;
+			Sign_Extend(borrow, z);
+			Storeinc(bx, z, y);
+#else
+			ys = *sx++ + carry;
+			carry = ys >> 16;
+			y = *bx - (ys & 0xffff) + borrow;
+			borrow = y >> 16;
+			Sign_Extend(borrow, y);
+			*bx++ = y & 0xffff;
+#endif
+			}
+			while(sx <= sxe);
+		bx = b->x;
+		bxe = bx + n;
+		if (!*bxe) {
+			while(--bxe > bx && !*bxe)
+				--n;
+			b->wds = n;
+			}
+		}
+	return q;
+	}
diff --git a/sys/src/ape/lib/ap/stdio/_fconv.c b/sys/src/ape/lib/ap/stdio/_fconv.c
new file mode 100755
index 000000000..fc72d4731
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/_fconv.c
@@ -0,0 +1,593 @@
+/* Common routines for _dtoa and strtod */
+
+#include "fconv.h"
+
+#ifdef DEBUG
+#include <stdio.h>
+#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
+#endif
+
+ double
+_tens[] = {
+		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+		1e20, 1e21, 1e22
+#ifdef VAX
+		, 1e23, 1e24
+#endif
+		};
+
+
+#ifdef IEEE_Arith
+double _bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
+double _tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
+#else
+#ifdef IBM
+double _bigtens[] = { 1e16, 1e32, 1e64 };
+double _tinytens[] = { 1e-16, 1e-32, 1e-64 };
+#else
+double _bigtens[] = { 1e16, 1e32 };
+double _tinytens[] = { 1e-16, 1e-32 };
+#endif
+#endif
+
+ static Bigint *freelist[Kmax+1];
+
+ Bigint *
+_Balloc(int k)
+{
+	int x;
+	Bigint *rv;
+
+	if (rv = freelist[k]) {
+		freelist[k] = rv->next;
+		}
+	else {
+		x = 1 << k;
+		rv = (Bigint *)malloc(sizeof(Bigint) + (x-1)*sizeof(long));
+		rv->k = k;
+		rv->maxwds = x;
+		}
+	rv->sign = rv->wds = 0;
+	return rv;
+	}
+
+ void
+_Bfree(Bigint *v)
+{
+	if (v) {
+		v->next = freelist[v->k];
+		freelist[v->k] = v;
+		}
+	}
+
+
+ Bigint *
+_multadd(Bigint *b, int m, int a)	/* multiply by m and add a */
+{
+	int i, wds;
+	unsigned long *x, y;
+#ifdef Pack_32
+	unsigned long xi, z;
+#endif
+	Bigint *b1;
+
+	wds = b->wds;
+	x = b->x;
+	i = 0;
+	do {
+#ifdef Pack_32
+		xi = *x;
+		y = (xi & 0xffff) * m + a;
+		z = (xi >> 16) * m + (y >> 16);
+		a = (int)(z >> 16);
+		*x++ = (z << 16) + (y & 0xffff);
+#else
+		y = *x * m + a;
+		a = (int)(y >> 16);
+		*x++ = y & 0xffff;
+#endif
+		}
+		while(++i < wds);
+	if (a) {
+		if (wds >= b->maxwds) {
+			b1 = Balloc(b->k+1);
+			Bcopy(b1, b);
+			Bfree(b);
+			b = b1;
+			}
+		b->x[wds++] = a;
+		b->wds = wds;
+		}
+	return b;
+	}
+
+ int
+_hi0bits(register unsigned long x)
+{
+	register int k = 0;
+
+	if (!(x & 0xffff0000)) {
+		k = 16;
+		x <<= 16;
+		}
+	if (!(x & 0xff000000)) {
+		k += 8;
+		x <<= 8;
+		}
+	if (!(x & 0xf0000000)) {
+		k += 4;
+		x <<= 4;
+		}
+	if (!(x & 0xc0000000)) {
+		k += 2;
+		x <<= 2;
+		}
+	if (!(x & 0x80000000)) {
+		k++;
+		if (!(x & 0x40000000))
+			return 32;
+		}
+	return k;
+	}
+
+ static int
+lo0bits(unsigned long *y)
+{
+	register int k;
+	register unsigned long x = *y;
+
+	if (x & 7) {
+		if (x & 1)
+			return 0;
+		if (x & 2) {
+			*y = x >> 1;
+			return 1;
+			}
+		*y = x >> 2;
+		return 2;
+		}
+	k = 0;
+	if (!(x & 0xffff)) {
+		k = 16;
+		x >>= 16;
+		}
+	if (!(x & 0xff)) {
+		k += 8;
+		x >>= 8;
+		}
+	if (!(x & 0xf)) {
+		k += 4;
+		x >>= 4;
+		}
+	if (!(x & 0x3)) {
+		k += 2;
+		x >>= 2;
+		}
+	if (!(x & 1)) {
+		k++;
+		x >>= 1;
+		if (!x & 1)
+			return 32;
+		}
+	*y = x;
+	return k;
+	}
+
+ Bigint *
+_i2b(int i)
+{
+	Bigint *b;
+
+	b = Balloc(1);
+	b->x[0] = i;
+	b->wds = 1;
+	return b;
+	}
+
+ Bigint *
+_mult(Bigint *a, Bigint *b)
+{
+	Bigint *c;
+	int k, wa, wb, wc;
+	unsigned long carry, y, z;
+	unsigned long *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
+#ifdef Pack_32
+	unsigned long z2;
+#endif
+
+	if (a->wds < b->wds) {
+		c = a;
+		a = b;
+		b = c;
+		}
+	k = a->k;
+	wa = a->wds;
+	wb = b->wds;
+	wc = wa + wb;
+	if (wc > a->maxwds)
+		k++;
+	c = Balloc(k);
+	for(x = c->x, xa = x + wc; x < xa; x++)
+		*x = 0;
+	xa = a->x;
+	xae = xa + wa;
+	xb = b->x;
+	xbe = xb + wb;
+	xc0 = c->x;
+#ifdef Pack_32
+	for(; xb < xbe; xb++, xc0++) {
+		if (y = *xb & 0xffff) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			do {
+				z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
+				carry = z >> 16;
+				z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
+				carry = z2 >> 16;
+				Storeinc(xc, z2, z);
+				}
+				while(x < xae);
+			*xc = carry;
+			}
+		if (y = *xb >> 16) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			z2 = *xc;
+			do {
+				z = (*x & 0xffff) * y + (*xc >> 16) + carry;
+				carry = z >> 16;
+				Storeinc(xc, z, z2);
+				z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
+				carry = z2 >> 16;
+				}
+				while(x < xae);
+			*xc = z2;
+			}
+		}
+#else
+	for(; xb < xbe; xc0++) {
+		if (y = *xb++) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			do {
+				z = *x++ * y + *xc + carry;
+				carry = z >> 16;
+				*xc++ = z & 0xffff;
+				}
+				while(x < xae);
+			*xc = carry;
+			}
+		}
+#endif
+	for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
+	c->wds = wc;
+	return c;
+	}
+
+ static Bigint *p5s;
+
+ Bigint *
+_pow5mult(Bigint *b, int k)
+{
+	Bigint *b1, *p5, *p51;
+	int i;
+	static int p05[3] = { 5, 25, 125 };
+
+	if (i = k & 3)
+		b = multadd(b, p05[i-1], 0);
+
+	if (!(k >>= 2))
+		return b;
+	if (!(p5 = p5s)) {
+		/* first time */
+		p5 = p5s = i2b(625);
+		p5->next = 0;
+		}
+	for(;;) {
+		if (k & 1) {
+			b1 = mult(b, p5);
+			Bfree(b);
+			b = b1;
+			}
+		if (!(k >>= 1))
+			break;
+		if (!(p51 = p5->next)) {
+			p51 = p5->next = mult(p5,p5);
+			p51->next = 0;
+			}
+		p5 = p51;
+		}
+	return b;
+	}
+
+ Bigint *
+_lshift(Bigint *b, int k)
+{
+	int i, k1, n, n1;
+	Bigint *b1;
+	unsigned long *x, *x1, *xe, z;
+
+#ifdef Pack_32
+	n = k >> 5;
+#else
+	n = k >> 4;
+#endif
+	k1 = b->k;
+	n1 = n + b->wds + 1;
+	for(i = b->maxwds; n1 > i; i <<= 1)
+		k1++;
+	b1 = Balloc(k1);
+	x1 = b1->x;
+	for(i = 0; i < n; i++)
+		*x1++ = 0;
+	x = b->x;
+	xe = x + b->wds;
+#ifdef Pack_32
+	if (k &= 0x1f) {
+		k1 = 32 - k;
+		z = 0;
+		do {
+			*x1++ = *x << k | z;
+			z = *x++ >> k1;
+			}
+			while(x < xe);
+		if (*x1 = z)
+			++n1;
+		}
+#else
+	if (k &= 0xf) {
+		k1 = 16 - k;
+		z = 0;
+		do {
+			*x1++ = *x << k  & 0xffff | z;
+			z = *x++ >> k1;
+			}
+			while(x < xe);
+		if (*x1 = z)
+			++n1;
+		}
+#endif
+	else do
+		*x1++ = *x++;
+		while(x < xe);
+	b1->wds = n1 - 1;
+	Bfree(b);
+	return b1;
+	}
+
+ int
+_cmp(Bigint *a, Bigint *b)
+{
+	unsigned long *xa, *xa0, *xb, *xb0;
+	int i, j;
+
+	i = a->wds;
+	j = b->wds;
+#ifdef DEBUG
+	if (i > 1 && !a->x[i-1])
+		Bug("cmp called with a->x[a->wds-1] == 0");
+	if (j > 1 && !b->x[j-1])
+		Bug("cmp called with b->x[b->wds-1] == 0");
+#endif
+	if (i -= j)
+		return i;
+	xa0 = a->x;
+	xa = xa0 + j;
+	xb0 = b->x;
+	xb = xb0 + j;
+	for(;;) {
+		if (*--xa != *--xb)
+			return *xa < *xb ? -1 : 1;
+		if (xa <= xa0)
+			break;
+		}
+	return 0;
+	}
+
+ Bigint *
+_diff(Bigint *a, Bigint *b)
+{
+	Bigint *c;
+	int i, wa, wb;
+	long borrow, y;	/* We need signed shifts here. */
+	unsigned long *xa, *xae, *xb, *xbe, *xc;
+#ifdef Pack_32
+	long z;
+#endif
+
+	i = cmp(a,b);
+	if (!i) {
+		c = Balloc(0);
+		c->wds = 1;
+		c->x[0] = 0;
+		return c;
+		}
+	if (i < 0) {
+		c = a;
+		a = b;
+		b = c;
+		i = 1;
+		}
+	else
+		i = 0;
+	c = Balloc(a->k);
+	c->sign = i;
+	wa = a->wds;
+	xa = a->x;
+	xae = xa + wa;
+	wb = b->wds;
+	xb = b->x;
+	xbe = xb + wb;
+	xc = c->x;
+	borrow = 0;
+#ifdef Pack_32
+	do {
+		y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
+		borrow = y >> 16;
+		Sign_Extend(borrow, y);
+		z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
+		borrow = z >> 16;
+		Sign_Extend(borrow, z);
+		Storeinc(xc, z, y);
+		}
+		while(xb < xbe);
+	while(xa < xae) {
+		y = (*xa & 0xffff) + borrow;
+		borrow = y >> 16;
+		Sign_Extend(borrow, y);
+		z = (*xa++ >> 16) + borrow;
+		borrow = z >> 16;
+		Sign_Extend(borrow, z);
+		Storeinc(xc, z, y);
+		}
+#else
+	do {
+		y = *xa++ - *xb++ + borrow;
+		borrow = y >> 16;
+		Sign_Extend(borrow, y);
+		*xc++ = y & 0xffff;
+		}
+		while(xb < xbe);
+	while(xa < xae) {
+		y = *xa++ + borrow;
+		borrow = y >> 16;
+		Sign_Extend(borrow, y);
+		*xc++ = y & 0xffff;
+		}
+#endif
+	while(!*--xc)
+		wa--;
+	c->wds = wa;
+	return c;
+	}
+
+ Bigint *
+_d2b(double darg, int *e, int *bits)
+{
+	Bigint *b;
+	int de, i, k;
+	unsigned long *x, y, z;
+	Dul d;
+#ifdef VAX
+	unsigned long d0, d1;
+	d.d = darg;
+	d0 = word0(d) >> 16 | word0(d) << 16;
+	d1 = word1(d) >> 16 | word1(d) << 16;
+#else
+	d.d = darg;
+#define d0 word0(d)
+#define d1 word1(d)
+#endif
+
+#ifdef Pack_32
+	b = Balloc(1);
+#else
+	b = Balloc(2);
+#endif
+	x = b->x;
+
+	z = d0 & Frac_mask;
+	d0 &= 0x7fffffff;	/* clear sign bit, which we ignore */
+#ifdef Sudden_Underflow
+	de = (int)(d0 >> Exp_shift);
+#ifndef IBM
+	z |= Exp_msk11;
+#endif
+#else
+	if (de = (int)(d0 >> Exp_shift))
+		z |= Exp_msk1;
+#endif
+#ifdef Pack_32
+	if (y = d1) {
+		if (k = lo0bits(&y)) {
+			x[0] = y | z << 32 - k;
+			z >>= k;
+			}
+		else
+			x[0] = y;
+		i = b->wds = (x[1] = z) ? 2 : 1;
+		}
+	else {
+#ifdef DEBUG
+		if (!z)
+			Bug("Zero passed to d2b");
+#endif
+		k = lo0bits(&z);
+		x[0] = z;
+		i = b->wds = 1;
+		k += 32;
+		}
+#else
+	if (y = d1) {
+		if (k = lo0bits(&y))
+			if (k >= 16) {
+				x[0] = y | z << 32 - k & 0xffff;
+				x[1] = z >> k - 16 & 0xffff;
+				x[2] = z >> k;
+				i = 2;
+				}
+			else {
+				x[0] = y & 0xffff;
+				x[1] = y >> 16 | z << 16 - k & 0xffff;
+				x[2] = z >> k & 0xffff;
+				x[3] = z >> k+16;
+				i = 3;
+				}
+		else {
+			x[0] = y & 0xffff;
+			x[1] = y >> 16;
+			x[2] = z & 0xffff;
+			x[3] = z >> 16;
+			i = 3;
+			}
+		}
+	else {
+#ifdef DEBUG
+		if (!z)
+			Bug("Zero passed to d2b");
+#endif
+		k = lo0bits(&z);
+		if (k >= 16) {
+			x[0] = z;
+			i = 0;
+			}
+		else {
+			x[0] = z & 0xffff;
+			x[1] = z >> 16;
+			i = 1;
+			}
+		k += 32;
+		}
+	while(!x[i])
+		--i;
+	b->wds = i + 1;
+#endif
+#ifndef Sudden_Underflow
+	if (de) {
+#endif
+#ifdef IBM
+		*e = (de - Bias - (P-1) << 2) + k;
+		*bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
+#else
+		*e = de - Bias - (P-1) + k;
+		*bits = P - k;
+#endif
+#ifndef Sudden_Underflow
+		}
+	else {
+		*e = de - Bias - (P-1) + 1 + k;
+#ifdef Pack_32
+		*bits = 32*i - hi0bits(x[i-1]);
+#else
+		*bits = (i+2)*16 - hi0bits(x[i]);
+#endif
+		}
+#endif
+	return b;
+	}
+#undef d0
+#undef d1
diff --git a/sys/src/ape/lib/ap/stdio/atexit.c b/sys/src/ape/lib/ap/stdio/atexit.c
new file mode 100755
index 000000000..16043eb57
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/atexit.c
@@ -0,0 +1,15 @@
+#include <unistd.h>
+#define	NONEXIT	34
+extern int (*_atexitfns[NONEXIT])(void);
+
+int
+atexit(int (*f)(void))
+{
+	int i;
+	for(i=0; i<NONEXIT; i++)
+		if(!_atexitfns[i]){
+			_atexitfns[i] = f;
+			return(0);
+		}
+	return(1);
+}
diff --git a/sys/src/ape/lib/ap/stdio/clearerr.c b/sys/src/ape/lib/ap/stdio/clearerr.c
new file mode 100755
index 000000000..904e33581
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/clearerr.c
@@ -0,0 +1,14 @@
+/*
+ * pANS stdio -- clearerr
+ */
+#include "iolib.h"
+void clearerr(FILE *f){
+	switch(f->state){
+	case ERR:
+		f->state=f->buf?RDWR:OPEN;
+		break;
+	case END:
+		f->state=RDWR;
+		break;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/exit.c b/sys/src/ape/lib/ap/stdio/exit.c
new file mode 100755
index 000000000..eaef6b304
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/exit.c
@@ -0,0 +1,17 @@
+#include <unistd.h>
+#define	NONEXIT	34
+int (*_atexitfns[NONEXIT])(void);
+void _doatexits(void){
+	int i, (*f)(void);
+	for(i = NONEXIT-1; i >= 0; i--)
+		if(_atexitfns[i]){
+			f = _atexitfns[i];
+			_atexitfns[i] = 0;	/* self defense against bozos */
+			(*f)();
+		}
+}
+void exit(int status)
+{
+	_doatexits();
+	_exit(status);
+}
diff --git a/sys/src/ape/lib/ap/stdio/fclose.c b/sys/src/ape/lib/ap/stdio/fclose.c
new file mode 100755
index 000000000..d14e83746
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fclose.c
@@ -0,0 +1,15 @@
+/*
+ * pANS stdio -- fclose
+ */
+#include "iolib.h"
+int fclose(FILE *f){
+	int error=0;
+	if(!f) return EOF;
+	if(f->state==CLOSED) return EOF;
+	if(fflush(f)==EOF) error=EOF;
+	if(f->flags&BALLOC) free(f->buf);
+	if(!(f->flags&STRING) && close(f->fd)<0) error=EOF;
+	f->state=CLOSED;
+	f->flags=0;
+	return error;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fconv.h b/sys/src/ape/lib/ap/stdio/fconv.h
new file mode 100755
index 000000000..ccc91e0cf
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fconv.h
@@ -0,0 +1,236 @@
+/****************************************************************
+ 
+  The author of this software (_dtoa, strtod) is David M. Gay.
+  Please send bug reports to
+	David M. Gay
+	Bell Laboratories, Room 2C-463
+	600 Mountain Avenue
+	Murray Hill, NJ 07974-2070
+	U.S.A.
+	dmg@research.bell-labs.com
+ */
+#include <stdlib.h>
+#include <string.h>
+#define _RESEARCH_SOURCE
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+#define CONST const
+
+/*
+ * #define IEEE_8087 for IEEE-arithmetic machines where the least
+ *	significant byte has the lowest address.
+ * #define IEEE_MC68k for IEEE-arithmetic machines where the most
+ *	significant byte has the lowest address.
+ * #define Sudden_Underflow for IEEE-format machines without gradual
+ *	underflow (i.e., that flush to zero on underflow).
+ * #define IBM for IBM mainframe-style floating-point arithmetic.
+ * #define VAX for VAX-style floating-point arithmetic.
+ * #define Unsigned_Shifts if >> does treats its left operand as unsigned.
+ * #define No_leftright to omit left-right logic in fast floating-point
+ *	computation of dtoa.
+ * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
+ * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
+ *	that use extended-precision instructions to compute rounded
+ *	products and quotients) with IBM.
+ * #define ROUND_BIASED for IEEE-format with biased rounding.
+ * #define Inaccurate_Divide for IEEE-format with correctly rounded
+ *	products but inaccurate quotients, e.g., for Intel i860.
+ * #define Just_16 to store 16 bits per 32-bit long when doing high-precision
+ *	integer arithmetic.  Whether this speeds things up or slows things
+ *	down depends on the machine and the number being converted.
+ */
+
+#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
+Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
+#endif
+
+typedef union {
+	double d;
+	unsigned long ul[2];
+} Dul;
+
+#ifdef IEEE_8087
+#define word0(x) ((x).ul[1])
+#define word1(x) ((x).ul[0])
+#else
+#define word0(x) ((x).ul[0])
+#define word1(x) ((x).ul[1])
+#endif
+
+#ifdef Unsigned_Shifts
+#define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000;
+#else
+#define Sign_Extend(a,b) /*no-op*/
+#endif
+
+/* The following definition of Storeinc is appropriate for MIPS processors.
+ * An alternative that might be better on some machines is
+ * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
+ */
+#if defined(IEEE_8087) + defined(VAX)
+#define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
+((unsigned short *)a)[0] = (unsigned short)c, a++)
+#else
+#define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
+((unsigned short *)a)[1] = (unsigned short)c, a++)
+#endif
+
+/* #define P DBL_MANT_DIG */
+/* Ten_pmax = floor(P*log(2)/log(5)) */
+/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
+/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
+/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
+
+#if defined(IEEE_8087) + defined(IEEE_MC68k)
+#define Exp_shift  20
+#define Exp_shift1 20
+#define Exp_msk1    0x100000
+#define Exp_msk11   0x100000
+#define Exp_mask  0x7ff00000
+#define P 53
+#define Bias 1023
+#define IEEE_Arith
+#define Emin (-1022)
+#define Exp_1  0x3ff00000
+#define Exp_11 0x3ff00000
+#define Ebits 11
+#define Frac_mask  0xfffff
+#define Frac_mask1 0xfffff
+#define Ten_pmax 22
+#define Bletch 0x10
+#define Bndry_mask  0xfffff
+#define Bndry_mask1 0xfffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 1
+#define Tiny0 0
+#define Tiny1 1
+#define Quick_max 14
+#define Int_max 14
+#define Infinite(x) (word0(x) == 0x7ff00000) /* sufficient test for here */
+#else
+#undef  Sudden_Underflow
+#define Sudden_Underflow
+#ifdef IBM
+#define Exp_shift  24
+#define Exp_shift1 24
+#define Exp_msk1   0x1000000
+#define Exp_msk11  0x1000000
+#define Exp_mask  0x7f000000
+#define P 14
+#define Bias 65
+#define Exp_1  0x41000000
+#define Exp_11 0x41000000
+#define Ebits 8	/* exponent has 7 bits, but 8 is the right value in b2d */
+#define Frac_mask  0xffffff
+#define Frac_mask1 0xffffff
+#define Bletch 4
+#define Ten_pmax 22
+#define Bndry_mask  0xefffff
+#define Bndry_mask1 0xffffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 4
+#define Tiny0 0x100000
+#define Tiny1 0
+#define Quick_max 14
+#define Int_max 15
+#else /* VAX */
+#define Exp_shift  23
+#define Exp_shift1 7
+#define Exp_msk1    0x80
+#define Exp_msk11   0x800000
+#define Exp_mask  0x7f80
+#define P 56
+#define Bias 129
+#define Exp_1  0x40800000
+#define Exp_11 0x4080
+#define Ebits 8
+#define Frac_mask  0x7fffff
+#define Frac_mask1 0xffff007f
+#define Ten_pmax 24
+#define Bletch 2
+#define Bndry_mask  0xffff007f
+#define Bndry_mask1 0xffff007f
+#define LSB 0x10000
+#define Sign_bit 0x8000
+#define Log2P 1
+#define Tiny0 0x80
+#define Tiny1 0
+#define Quick_max 15
+#define Int_max 15
+#endif
+#endif
+
+#ifndef IEEE_Arith
+#define ROUND_BIASED
+#endif
+
+#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
+#define Big1 0xffffffff
+
+#ifndef Just_16
+/* When Pack_32 is not defined, we store 16 bits per 32-bit long.
+ * This makes some inner loops simpler and sometimes saves work
+ * during multiplications, but it often seems to make things slightly
+ * slower.  Hence the default is now to store 32 bits per long.
+ */
+#ifndef Pack_32
+#define Pack_32
+#endif
+#endif
+
+#define Kmax 15
+
+ struct
+Bigint {
+	struct Bigint *next;
+	int k, maxwds, sign, wds;
+	unsigned long x[1];
+	};
+
+ typedef struct Bigint Bigint;
+
+/* This routines shouldn't be visible externally */
+extern Bigint	*_Balloc(int);
+extern void	_Bfree(Bigint *);
+extern Bigint	*_multadd(Bigint *, int, int);
+extern int	_hi0bits(unsigned long);
+extern Bigint	*_mult(Bigint *, Bigint *);
+extern Bigint	*_pow5mult(Bigint *, int);
+extern Bigint	*_lshift(Bigint *, int);
+extern int	_cmp(Bigint *, Bigint *);
+extern Bigint	*_diff(Bigint *, Bigint *);
+extern Bigint	*_d2b(double, int *, int *);
+extern Bigint	*_i2b(int);
+
+extern double	_tens[], _bigtens[], _tinytens[];
+
+#ifdef IEEE_Arith
+#define n_bigtens 5
+#else
+#ifdef IBM
+#define n_bigtens 3
+#else
+#define n_bigtens 2
+#endif
+#endif
+
+#define Balloc(x) _Balloc(x)
+#define Bfree(x) _Bfree(x)
+#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+y->wds*sizeof(long) + 2*sizeof(int))
+#define multadd(x,y,z) _multadd(x,y,z)
+#define hi0bits(x) _hi0bits(x)
+#define i2b(x) _i2b(x)
+#define mult(x,y) _mult(x,y)
+#define pow5mult(x,y) _pow5mult(x,y)
+#define lshift(x,y) _lshift(x,y)
+#define cmp(x,y) _cmp(x,y)
+#define diff(x,y) _diff(x,y)
+#define d2b(x,y,z) _d2b(x,y,z)
+
+#define tens _tens
+#define bigtens _bigtens
+#define tinytens _tinytens
diff --git a/sys/src/ape/lib/ap/stdio/fdopen.c b/sys/src/ape/lib/ap/stdio/fdopen.c
new file mode 100755
index 000000000..0c585b965
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fdopen.c
@@ -0,0 +1,33 @@
+/*
+ * Posix stdio -- fdopen
+ */
+#include "iolib.h"
+/*
+ * Open the named file with the given mode, using the given FILE
+ * Legal modes are given below, `additional characters may follow these sequences':
+ * r rb		open to read
+ * w wb		open to write, truncating
+ * a ab		open to write positioned at eof, creating if non-existant
+ * r+ r+b rb+	open to read and write, creating if non-existant
+ * w+ w+b wb+	open to read and write, truncating
+ * a+ a+b ab+	open to read and write, positioned at eof, creating if non-existant.
+ */
+FILE *fdopen(const int fd, const char *mode){
+	FILE *f;
+	for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++)
+		if(f->state==CLOSED)
+			break;
+	if(f==&_IO_stream[FOPEN_MAX])
+		return NULL;
+	f->fd=fd;
+	if(mode[0]=='a')
+		lseek(f->fd, 0L, 2);
+	if(f->fd==-1) return NULL;
+	f->flags=0;
+	f->state=OPEN;
+	f->buf=0;
+	f->rp=0;
+	f->wp=0;
+	f->lp=0;
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/stdio/feof.c b/sys/src/ape/lib/ap/stdio/feof.c
new file mode 100755
index 000000000..9c2ce9077
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/feof.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- feof
+ */
+#include "iolib.h"
+int feof(FILE *f){
+	return f->state==END;
+}
diff --git a/sys/src/ape/lib/ap/stdio/ferror.c b/sys/src/ape/lib/ap/stdio/ferror.c
new file mode 100755
index 000000000..0c705c5d8
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/ferror.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- ferror
+ */
+#include "iolib.h"
+int ferror(FILE *f){
+	return f->state==ERR;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fflush.c b/sys/src/ape/lib/ap/stdio/fflush.c
new file mode 100755
index 000000000..50a9da28f
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fflush.c
@@ -0,0 +1,31 @@
+/*
+ * pANS stdio -- fflush
+ */
+#include "iolib.h"
+int fflush(FILE *f){
+	int error, cnt;
+	if(f==NULL){
+		error=0;
+		for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++)
+			if(f->state==WR && fflush(f)==EOF)
+				error=EOF;
+		return error;
+	}
+	if(f->flags&STRING) return EOF;
+	switch(f->state){
+	default:	/* OPEN RDWR EOF RD */
+		return 0;
+	case CLOSED:
+	case ERR:
+		return EOF;
+	case WR:
+		cnt=(f->flags&LINEBUF?f->lp:f->wp)-f->buf;
+		if(cnt && write(f->fd, f->buf, cnt)!=cnt){
+			f->state=ERR;
+			return EOF;
+		}
+		f->rp=f->wp=f->buf;
+		f->state=RDWR;
+		return 0;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/fgetc.c b/sys/src/ape/lib/ap/stdio/fgetc.c
new file mode 100755
index 000000000..08c5ad03b
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fgetc.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- fgetc
+ */
+#include "iolib.h"
+int fgetc(FILE *f){
+	return getc(f);
+}
diff --git a/sys/src/ape/lib/ap/stdio/fgetpos.c b/sys/src/ape/lib/ap/stdio/fgetpos.c
new file mode 100755
index 000000000..c8edc57b1
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fgetpos.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- fgetpos
+ */
+#include "iolib.h"
+int fgetpos(FILE *f, fpos_t *pos){
+	*pos=ftell(f);
+	return *pos==-1?-1:0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fgets.c b/sys/src/ape/lib/ap/stdio/fgets.c
new file mode 100755
index 000000000..5032735e0
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fgets.c
@@ -0,0 +1,17 @@
+/*
+ * pANS stdio -- fgets
+ */
+#include "iolib.h"
+char *fgets(char *as, int n, FILE *f){
+	int c=0;
+	char *s=as;
+	while(n>1 && (c=getc(f))!=EOF){
+		*s++=c;
+		--n;
+		if(c=='\n') break;
+	}
+	if(c==EOF && s==as
+	|| ferror(f)) return NULL;
+	if(n) *s='\0';
+	return as;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fileno.c b/sys/src/ape/lib/ap/stdio/fileno.c
new file mode 100755
index 000000000..2dd6fdb85
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fileno.c
@@ -0,0 +1,10 @@
+/*
+ * Posix stdio -- fileno
+ */
+#include "iolib.h"
+int fileno(FILE *f){
+	if(f==NULL)
+		return -1;
+	else
+		return f->fd;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fopen.c b/sys/src/ape/lib/ap/stdio/fopen.c
new file mode 100755
index 000000000..edf27172c
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fopen.c
@@ -0,0 +1,11 @@
+/*
+ * pANS stdio -- fopen
+ */
+#include "iolib.h"
+FILE *fopen(const char *name, const char *mode){
+	FILE *f;
+	for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++)
+		if(f->state==CLOSED)
+			return freopen(name, mode, f);
+	return NULL;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fprintf.c b/sys/src/ape/lib/ap/stdio/fprintf.c
new file mode 100755
index 000000000..9f3a861cc
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fprintf.c
@@ -0,0 +1,12 @@
+/*
+ * pANS stdio -- fprintf
+ */
+#include "iolib.h"
+int fprintf(FILE *f, const char *fmt, ...){
+	int n;
+	va_list args;
+	va_start(args, fmt);
+	n=vfprintf(f, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fputc.c b/sys/src/ape/lib/ap/stdio/fputc.c
new file mode 100755
index 000000000..0a482e20c
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fputc.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- fputc
+ */
+#include "iolib.h"
+int fputc(int c, FILE *f){
+	return putc(c, f);	/* This can be made more fair to _IOLBF-mode streams */
+}
diff --git a/sys/src/ape/lib/ap/stdio/fputs.c b/sys/src/ape/lib/ap/stdio/fputs.c
new file mode 100755
index 000000000..d0406b0e5
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fputs.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- fputs
+ */
+#include "iolib.h"
+int fputs(const char *s, FILE *f){
+	while(*s) putc(*s++, f);
+	return ferror(f)?EOF:0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fread.c b/sys/src/ape/lib/ap/stdio/fread.c
new file mode 100755
index 000000000..3345011b6
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fread.c
@@ -0,0 +1,45 @@
+/*
+ * pANS stdio -- fread
+ */
+#include "iolib.h"
+#include <string.h>
+
+#define BIGN (BUFSIZ/2)
+
+size_t fread(void *p, size_t recl, size_t nrec, FILE *f){
+	char *s;
+	int n, d, c;
+
+	s=(char *)p;
+	n=recl*nrec;
+	while(n>0){
+		d=f->wp-f->rp;
+		if(d>0){
+			if(d>n)
+				d=n;
+			memcpy(s, f->rp, d);
+			f->rp+=d;
+		}else{
+			if(n >= BIGN && f->state==RD && !(f->flags&STRING) && f->buf!=f->unbuf){
+				d=read(f->fd, s, n);
+				if(d<=0){
+					f->state=(d==0)?END:ERR;
+					goto ret;
+				}
+			}else{
+ 				c=_IO_getc(f);
+				if(c==EOF)
+					goto ret;
+				*s=c;
+				d=1;
+			}
+		}
+		s+=d;
+		n-=d;
+	}
+    ret:
+	if(recl)
+		return (s-(char*)p)/recl;
+	else
+		return s-(char*)p;
+}
diff --git a/sys/src/ape/lib/ap/stdio/freopen.c b/sys/src/ape/lib/ap/stdio/freopen.c
new file mode 100755
index 000000000..ba586bbfc
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/freopen.c
@@ -0,0 +1,66 @@
+/*
+ * pANS stdio -- freopen
+ */
+#include "iolib.h"
+/*
+ * Open the named file with the given mode, using the given FILE
+ * Legal modes are given below, `additional characters may follow these sequences':
+ * r rb		open to read
+ * w wb		open to write, truncating
+ * a ab		open to write positioned at eof, creating if non-existant
+ * r+ r+b rb+	open to read and write, creating if non-existant
+ * w+ w+b wb+	open to read and write, truncating
+ * a+ a+b ab+	open to read and write, positioned at eof, creating if non-existant.
+ */
+FILE *freopen(const char *name, const char *mode, FILE *f){
+	int m;
+
+	if(f->state!=CLOSED){
+		fclose(f);
+/* premature; fall through and see what happens */
+/*		f->state=OPEN; */
+	}
+
+	m = *mode++;
+	if(m == 0)
+		return NULL;
+	if(*mode == 'b')
+		mode++;
+	switch(m){
+	default:
+		return NULL;
+	case 'r':
+		f->fd=open(name, (*mode == '+'? O_RDWR: O_RDONLY));
+		break;
+	case 'w':
+		f->fd=creat(name, 0666);	/* implicitly O_WRONLY */
+		/* for O_RDWR, have to creat, close, open */
+		if(*mode == '+' && f->fd >= 0) {
+			close(f->fd);
+			f->fd=open(name, O_RDWR);
+		}
+		break;
+	case 'a':
+		f->fd=open(name, (*mode == '+'? O_RDWR: O_WRONLY));
+		if(f->fd<0) {
+			f->fd=creat(name, 0666);
+			/* for O_RDWR, have to creat, close, open */
+			if(*mode == '+' && f->fd >= 0) {
+				close(f->fd);
+				f->fd=open(name, O_RDWR);
+			}
+		}
+		lseek(f->fd, 0L, 2);
+		break;
+	}
+
+	if(f->fd==-1)
+		return NULL;
+	f->flags=(mode[0]=='a')? APPEND : 0;
+	f->state=OPEN;
+	f->buf=0;
+	f->rp=0;
+	f->wp=0;
+	f->lp=0;
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fscanf.c b/sys/src/ape/lib/ap/stdio/fscanf.c
new file mode 100755
index 000000000..3d9d874e8
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fscanf.c
@@ -0,0 +1,12 @@
+/*
+ * pANS stdio -- fscanf
+ */
+#include "iolib.h"
+int fscanf(FILE *f, const char *fmt, ...){
+	int n;
+	va_list args;
+	va_start(args, fmt);
+	n=vfscanf(f, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fseek.c b/sys/src/ape/lib/ap/stdio/fseek.c
new file mode 100755
index 000000000..fba570d09
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fseek.c
@@ -0,0 +1,24 @@
+/*
+ * pANS stdio -- fseek
+ */
+#include "iolib.h"
+int fseek(FILE *f, long offs, int type){
+	switch(f->state){
+	case ERR:
+	case CLOSED:
+		return -1;
+	case WR:
+		fflush(f);
+		break;
+	case RD:
+		if(type==1 && f->buf!=f->unbuf)
+			offs-=f->wp-f->rp;
+		break;
+	}
+	if(f->flags&STRING || lseek(f->fd, offs, type)==-1)
+		return -1;
+	if(f->state==RD) f->rp=f->wp=f->buf;
+	if(f->state!=OPEN)
+		f->state=RDWR;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fseeko.c b/sys/src/ape/lib/ap/stdio/fseeko.c
new file mode 100755
index 000000000..469d04419
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fseeko.c
@@ -0,0 +1,24 @@
+/*
+ * pANS stdio -- fseeko
+ */
+#include "iolib.h"
+int fseeko(FILE *f, off_t offs, int type){
+	switch(f->state){
+	case ERR:
+	case CLOSED:
+		return -1;
+	case WR:
+		fflush(f);
+		break;
+	case RD:
+		if(type==1 && f->buf!=f->unbuf)
+			offs-=f->wp-f->rp;
+		break;
+	}
+	if(f->flags&STRING || lseek(f->fd, offs, type)==-1)
+		return -1;
+	if(f->state==RD) f->rp=f->wp=f->buf;
+	if(f->state!=OPEN)
+		f->state=RDWR;
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fsetpos.c b/sys/src/ape/lib/ap/stdio/fsetpos.c
new file mode 100755
index 000000000..540e83a7e
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fsetpos.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- fsetpos
+ */
+#include "iolib.h"
+int fsetpos(FILE *f, const fpos_t *pos){
+	return fseek(f, *pos, SEEK_SET);
+}
diff --git a/sys/src/ape/lib/ap/stdio/ftell.c b/sys/src/ape/lib/ap/stdio/ftell.c
new file mode 100755
index 000000000..3693589ea
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/ftell.c
@@ -0,0 +1,16 @@
+/*
+ * pANS stdio -- ftell
+ */
+#include "iolib.h"
+long ftell(FILE *f){
+	long seekp=lseek(f->fd, 0L, 1);
+	if(seekp<0) return -1;		/* enter error state? */
+	switch(f->state){
+	default:
+		return seekp;
+	case RD:
+		return seekp-(f->wp-f->rp);
+	case WR:
+		return (f->flags&LINEBUF?f->lp:f->wp)-f->buf+seekp;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/ftello.c b/sys/src/ape/lib/ap/stdio/ftello.c
new file mode 100755
index 000000000..4ebb7b138
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/ftello.c
@@ -0,0 +1,16 @@
+/*
+ * pANS stdio -- ftello
+ */
+#include "iolib.h"
+off_t ftello(FILE *f){
+	off_t seekp=lseek(f->fd, 0L, 1);
+	if(seekp<0) return -1;		/* enter error state? */
+	switch(f->state){
+	default:
+		return seekp;
+	case RD:
+		return seekp-(f->wp-f->rp);
+	case WR:
+		return (f->flags&LINEBUF?f->lp:f->wp)-f->buf+seekp;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/ftoa.c b/sys/src/ape/lib/ap/stdio/ftoa.c
new file mode 100755
index 000000000..b241d2d43
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/ftoa.c
@@ -0,0 +1,41 @@
+#include <math.h>
+#include <stdlib.h>
+double pow10(int);
+#define	NDIG	18
+#define	NFTOA	(NDIG+4)
+/*
+ * convert floating to ascii.  ftoa returns an integer e such that
+ * f=g*10**e, with .1<=|g|<1 (e=0 when g==0) and puts an ascii
+ * representation of g in the buffer pointed to by bp.  bp[0] will
+ * be '+' or '-', and bp[1] to bp[NFTOA-2]
+ * will be appropriate digits of g. bp[NFTOA-1] will be '\0'
+ */
+int ftoa(double f, char *bp){
+	int e, e1, e2, i;
+	double digit, g, p;
+	if(f>=0) *bp++='+';
+	else{
+		f=-f;
+		*bp++='-';
+	}
+	/* find e such that f==0 or 1<=f*pow10(e)<10, and set f=f*pow10(e) */
+	if(f==0.) e=1;
+	else{
+		frexp(f, &e);
+		e=-e*30103/100000;
+		/* split in 2 pieces to guard against overflow in extreme cases */
+		e1=e/2;
+		e2=e-e1;
+		p=f*pow10(e2);
+		while((g=p*pow10(e1))<1.) e1++;
+		while((g=p*pow10(e1))>=10.) --e1;
+		e=e1+e2;
+		f=g;
+	}
+	for(i=0;i!=NDIG;i++){
+		f=modf(f, &digit)*10.;
+		*bp++=digit+'0';
+	}
+	*bp='\0';
+	return 1-e;
+}
diff --git a/sys/src/ape/lib/ap/stdio/fwrite.c b/sys/src/ape/lib/ap/stdio/fwrite.c
new file mode 100755
index 000000000..5e871c069
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/fwrite.c
@@ -0,0 +1,55 @@
+/*
+ * pANS stdio -- fwrite
+ */
+#include "iolib.h"
+#include <string.h>
+
+#define BIGN (BUFSIZ/2)
+
+size_t fwrite(const void *p, size_t recl, size_t nrec, FILE *f){
+	char *s;
+	int n, d;
+
+	s=(char *)p;
+	n=recl*nrec;
+	while(n>0){
+		d=f->rp-f->wp;
+		if(d>0){
+			if(d>n)
+				d=n;
+			memcpy(f->wp, s, d);
+			f->wp+=d;
+		}else{
+			if(n>=BIGN && f->state==WR && !(f->flags&(STRING|LINEBUF)) && f->buf!=f->unbuf){
+				d=f->wp-f->buf;
+				if(d>0){
+					if(f->flags&APPEND)
+						lseek(f->fd, 0L, SEEK_END);
+					if(write(f->fd, f->buf, d)!=d){
+						f->state=ERR;
+						goto ret;
+					}
+					f->wp=f->rp=f->buf;
+				}
+				if(f->flags&APPEND)
+					lseek(f->fd, 0L, SEEK_END);
+				d=write(f->fd, s, n);
+				if(d<=0){
+					f->state=ERR;
+					goto ret;
+				}
+			}else{
+				if(_IO_putc(*s, f)==EOF)
+					goto ret;
+				d=1;
+			}
+		}
+		s+=d;
+		n-=d;
+	}
+    ret:
+	if(recl)
+		return (s-(char*)p)/recl;
+	else
+		return s-(char*)p;
+}
diff --git a/sys/src/ape/lib/ap/stdio/getc.c b/sys/src/ape/lib/ap/stdio/getc.c
new file mode 100755
index 000000000..4096972bf
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/getc.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- getc
+ */
+#include "iolib.h"
+#undef getc
+int getc(FILE *f){
+	return fgetc(f);
+}
diff --git a/sys/src/ape/lib/ap/stdio/getchar.c b/sys/src/ape/lib/ap/stdio/getchar.c
new file mode 100755
index 000000000..f42c119c6
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/getchar.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- getchar
+ */
+#include "iolib.h"
+#undef getchar
+int getchar(void){
+	return fgetc(stdin);
+}
diff --git a/sys/src/ape/lib/ap/stdio/gets.c b/sys/src/ape/lib/ap/stdio/gets.c
new file mode 100755
index 000000000..909c21485
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/gets.c
@@ -0,0 +1,17 @@
+/*
+ * pANS stdio -- gets
+ */
+#include "iolib.h"
+char *gets(char *as){
+#ifdef secure
+	stdin->flags|=ERR;
+	return NULL;
+#else
+	char *s=as;
+	int c;
+	while((c=getchar())!='\n' && c!=EOF) *s++=c;
+	if(c!=EOF || s!=as) *s='\0';
+	else return NULL;
+	return as;
+#endif
+}
diff --git a/sys/src/ape/lib/ap/stdio/iolib.h b/sys/src/ape/lib/ap/stdio/iolib.h
new file mode 100755
index 000000000..3a5bd63a0
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/iolib.h
@@ -0,0 +1,44 @@
+/*
+ * pANS stdio -- definitions
+ * The following names are defined in the pANS:
+ *	FILE	 	fpos_t		_IOFBF		_IOLBF		_IONBF
+ *	BUFSIZ		EOF		FOPEN_MAX	FILENAME_MAX	L_tmpnam
+ *	SEEK_CUR	SEEK_END	SEEK_SET	TMP_MAX		stderr
+ *	stdin		stdout		remove		rename		tmpfile
+ *	tmpnam		fclose		fflush		fopen		freopen
+ *	setbuf		setvbuf		fprintf		fscanf		printf
+ *	scanf		sprintf		sscanf		vfprintf	vprintf
+ *	vsprintf	fgetc		fgets		fputc		fputs
+ *	getc		getchar		gets		putc		putchar
+ *	puts		ungetc		fread		fwrite		fgetpos
+ *	fseek		fsetpos		ftell		rewind		clearerr
+ *	feof		ferror		perror	
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+/*
+ * Flag bits
+ */
+#define	BALLOC	1	/* did stdio malloc fd->buf? */
+#define	LINEBUF	2	/* is stream line buffered? */
+#define	STRING	4	/* output to string, instead of file */
+#define APPEND	8	/* append mode output */
+/*
+ * States
+ */
+#define	CLOSED	0	/* file not open */
+#define	OPEN	1	/* file open, but no I/O buffer allocated yet */
+#define	RDWR	2	/* open, buffer allocated, ok to read or write */
+#define	RD	3	/* open, buffer allocated, ok to read but not write */
+#define	WR	4	/* open, buffer allocated, ok to write but not read */
+#define	ERR	5	/* open, but an uncleared error occurred */
+#define	END	6	/* open, but at eof */
+char *strerror(int errno);
+int _IO_setvbuf(FILE *);
+FILE *_IO_sopenr(const char*);
+FILE *_IO_sopenw(void);
+char *_IO_sclose(FILE *);
diff --git a/sys/src/ape/lib/ap/stdio/mkfile b/sys/src/ape/lib/ap/stdio/mkfile
new file mode 100755
index 000000000..17be0da58
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/mkfile
@@ -0,0 +1,68 @@
+APE=/sys/src/ape
+<$APE/config
+LIB=/$objtype/lib/ape/libap.a
+OFILES=\
+	_IO_getc.$O\
+	_IO_putc.$O\
+	_dtoa.$O\
+	_fconv.$O\
+	clearerr.$O\
+	atexit.$O\
+	exit.$O\
+	fclose.$O\
+	fdopen.$O\
+	feof.$O\
+	ferror.$O\
+	fflush.$O\
+	fgetc.$O\
+	fgetpos.$O\
+	fgets.$O\
+	fileno.$O\
+	fopen.$O\
+	fprintf.$O\
+	fputc.$O\
+	fputs.$O\
+	fread.$O\
+	freopen.$O\
+	fscanf.$O\
+	fseek.$O\
+	fseeko.$O\
+	fsetpos.$O\
+	ftell.$O\
+	ftello.$O\
+	ftoa.$O\
+	fwrite.$O\
+	getc.$O\
+	getchar.$O\
+	gets.$O\
+	perror.$O\
+	pow10.$O\
+	printf.$O\
+	putc.$O\
+	putchar.$O\
+	puts.$O\
+	remove.$O\
+	rewind.$O\
+	scanf.$O\
+	sclose.$O\
+	setbuf.$O\
+	setvbuf.$O\
+	snprintf.$O\
+	sopenr.$O\
+	sopenw.$O\
+	sprintf.$O\
+	sscanf.$O\
+	stdio.$O\
+	strerror.$O\
+	strtod.$O\
+	tmpnam.$O\
+	ungetc.$O\
+	vfprintf.$O\
+	vfscanf.$O\
+	vprintf.$O\
+	vsprintf.$O\
+	vsnprintf.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE
diff --git a/sys/src/ape/lib/ap/stdio/perror.c b/sys/src/ape/lib/ap/stdio/perror.c
new file mode 100755
index 000000000..71f5c41f0
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/perror.c
@@ -0,0 +1,11 @@
+/*
+ * pANS stdio -- perror
+ */
+#include "iolib.h"
+void perror(const char *s){
+	extern int errno;
+	if(s!=NULL && *s != '\0') fputs(s, stderr), fputs(": ", stderr);
+	fputs(strerror(errno), stderr);
+	putc('\n', stderr);
+	fflush(stderr);
+}
diff --git a/sys/src/ape/lib/ap/stdio/pow10.c b/sys/src/ape/lib/ap/stdio/pow10.c
new file mode 100755
index 000000000..fc2aec265
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/pow10.c
@@ -0,0 +1,30 @@
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+
+static	long	tab[] =
+{
+	1L, 10L, 100L, 1000L, 10000L,
+	100000L, 1000000L, 10000000L
+};
+
+double
+pow10(int n)
+{
+	int m;
+
+	if(n > DBL_MAX_10_EXP){
+		errno = ERANGE;
+		return HUGE_VAL;
+	}
+	if(n < DBL_MIN_10_EXP){
+		errno = ERANGE;
+		return 0.0;
+	}
+	if(n < 0)
+		return 1/pow10(-n);
+	if(n < sizeof(tab)/sizeof(tab[0]))
+		return tab[n];
+	m = n/2;
+	return pow10(m) * pow10(n-m);
+}
diff --git a/sys/src/ape/lib/ap/stdio/printf.c b/sys/src/ape/lib/ap/stdio/printf.c
new file mode 100755
index 000000000..8880b9d8d
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/printf.c
@@ -0,0 +1,12 @@
+/*
+ * pANS stdio -- printf
+ */
+#include "iolib.h"
+int printf(const char *fmt, ...){
+	int n;
+	va_list args;
+	va_start(args, fmt);
+	n=vfprintf(stdout, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/putc.c b/sys/src/ape/lib/ap/stdio/putc.c
new file mode 100755
index 000000000..9cffeeb01
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/putc.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- putc
+ */
+#include "iolib.h"
+#undef putc
+int putc(int c, FILE *f){
+	return fputc(c, f);
+}
diff --git a/sys/src/ape/lib/ap/stdio/putchar.c b/sys/src/ape/lib/ap/stdio/putchar.c
new file mode 100755
index 000000000..7350012f2
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/putchar.c
@@ -0,0 +1,8 @@
+/*
+ * pANS stdio -- getchar
+ */
+#include "iolib.h"
+#undef putchar
+int putchar(int c){
+	return fputc(c, stdout);
+}
diff --git a/sys/src/ape/lib/ap/stdio/puts.c b/sys/src/ape/lib/ap/stdio/puts.c
new file mode 100755
index 000000000..b25c4718d
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/puts.c
@@ -0,0 +1,9 @@
+/*
+ * pANS stdio -- puts
+ */
+#include "iolib.h"
+int puts(const char *s){
+	fputs(s, stdout);
+	putchar('\n');
+	return ferror(stdin)?EOF:0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/rdline.c b/sys/src/ape/lib/ap/stdio/rdline.c
new file mode 100755
index 000000000..6281a97e8
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/rdline.c
@@ -0,0 +1,65 @@
+/*
+ * pANS stdio -- rdline
+ * This is not a pANS routine.
+ */
+#include "iolib.h"
+#include <string.h>
+
+char *rdline(FILE *f, char **ep){
+	int cnt;
+	char *nlp, *vp;
+	switch(f->state){
+	default:	/* CLOSED, WR, ERR, EOF */
+		return NULL;
+	case OPEN:
+		_IO_setvbuf(f);
+	case RDWR:
+		f->state=RD;
+	case RD:
+		if(f->bufl==0){		/* Called by a comedian! */
+			f->state=ERR;
+			return NULL;
+		}
+		vp=f->rp;
+		for(;;){
+			/*
+			 * Look for a newline.
+			 * If none found, slide the partial line to the beginning
+			 * of the buffer, read some more and keep looking.
+			 */
+			nlp=memchr(f->rp, '\n', f->wp-f->rp);
+			if(nlp!=0) break;
+			if(f->flags&STRING){
+				f->rp=f->wp;
+				if(ep) *ep=f->wp;
+				return vp;
+			}
+			if(f->rp!=f->buf){
+				memmove(f->buf, f->rp, f->wp-f->rp);
+				f->wp-=f->rp-f->buf;
+				f->rp=f->buf;
+				vp=f->rp;
+			}
+			cnt=f->bufl-(f->wp-f->buf);
+			if(cnt==0){	/* no room left */
+				nlp=f->wp-1;
+				break;
+			}
+			cnt=read(f->fd, f->wp, cnt);
+			if(cnt==-1){
+				f->state=ERR;
+				return NULL;
+			}
+			if(cnt==0){	/* is this ok? */
+				f->state=EOF;
+				return NULL;
+			}
+			f->rp=f->wp;
+			f->wp+=cnt;
+		}
+		*nlp='\0';
+		f->rp=nlp+1;
+		if(ep) *ep=nlp;
+		return vp;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/remove.c b/sys/src/ape/lib/ap/stdio/remove.c
new file mode 100755
index 000000000..bb30c94d5
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/remove.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- remove
+ */
+#include "iolib.h"
+int remove(const char *f){
+	return unlink((char *)f);
+}
diff --git a/sys/src/ape/lib/ap/stdio/rename.c b/sys/src/ape/lib/ap/stdio/rename.c
new file mode 100755
index 000000000..6232407f1
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/rename.c
@@ -0,0 +1,12 @@
+/*
+ * pANS stdio -- rename
+ */
+#include "iolib.h"
+int rename(const char *old, const char *new){
+	if(link((char *)old, (char *)new)<0) return -1;
+	if(unlink((char *)old)<0){
+		unlink((char *)new);
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/rewind.c b/sys/src/ape/lib/ap/stdio/rewind.c
new file mode 100755
index 000000000..0cfdb957c
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/rewind.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- rewind
+ */
+#include "iolib.h"
+void rewind(FILE *f){
+	fseek(f, 0L, SEEK_SET);
+}
diff --git a/sys/src/ape/lib/ap/stdio/scanf.c b/sys/src/ape/lib/ap/stdio/scanf.c
new file mode 100755
index 000000000..30a631cc9
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/scanf.c
@@ -0,0 +1,12 @@
+/*
+ * pANS stdio -- scanf
+ */
+#include "iolib.h"
+int scanf(const char *fmt, ...){
+	int n;
+	va_list args;
+	va_start(args, fmt);
+	n=vfscanf(stdin, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/sclose.c b/sys/src/ape/lib/ap/stdio/sclose.c
new file mode 100755
index 000000000..d55396a3a
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/sclose.c
@@ -0,0 +1,37 @@
+/*
+ * pANS stdio -- sclose
+ */
+#include "iolib.h"
+#include <stdlib.h>
+
+char *_IO_sclose(FILE *f){
+	switch(f->state){
+	default:	/* ERR CLOSED */
+		if(f->buf && f->flags&BALLOC)
+			free(f->buf);
+		f->state=CLOSED;
+		f->flags=0;
+		return NULL;
+	case OPEN:
+		f->buf=malloc(1);
+		f->buf[0]='\0';
+		break;
+	case RD:
+	case END:
+		f->flags=0;
+		break;
+	case RDWR:
+	case WR:
+		if(f->wp==f->rp){
+			if(f->flags&BALLOC)
+				f->buf=realloc(f->buf, f->bufl+1);
+			if(f->buf==NULL) return NULL;
+		}
+		*f->wp='\0';
+		f->flags=0;
+		break;
+	}
+	f->state=CLOSED;
+	f->flags=0;
+	return f->buf;
+}
diff --git a/sys/src/ape/lib/ap/stdio/setbuf.c b/sys/src/ape/lib/ap/stdio/setbuf.c
new file mode 100755
index 000000000..31c5d3e1e
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/setbuf.c
@@ -0,0 +1,17 @@
+/*
+ * pANS stdio -- setbuf
+ */
+#include "iolib.h"
+void setbuf(FILE *f, char *buf){
+	if(f->state==OPEN){
+		if(buf)
+			f->bufl=BUFSIZ;
+		else{
+			buf=f->unbuf;
+			f->bufl=0;
+		}
+		f->rp=f->wp=f->lp=f->buf=buf;
+		f->state=RDWR;
+	}
+	/* else error, but there's no way to report it */
+}
diff --git a/sys/src/ape/lib/ap/stdio/setvbuf.c b/sys/src/ape/lib/ap/stdio/setvbuf.c
new file mode 100755
index 000000000..58bea0098
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/setvbuf.c
@@ -0,0 +1,39 @@
+/*
+ * pANS stdio -- setvbuf
+ */
+#include "iolib.h"
+#include <stdlib.h>
+int setvbuf(FILE *f, char *buf, int mode, size_t size){
+	if(f->state!=OPEN){
+		f->state=ERR;
+		return -1;
+	}
+	f->state=RDWR;
+	switch(mode){
+	case _IOLBF:
+		f->flags|=LINEBUF;
+	case _IOFBF:
+		if(buf==0){
+			buf=malloc(size);
+			if(buf==0){
+				f->state=ERR;
+				return -1;
+			}
+			f->flags|=BALLOC;
+		}
+		f->bufl=size;
+		break;
+	case _IONBF:
+		buf=f->unbuf;
+		f->bufl=0;
+		break;
+	}
+	f->rp=f->wp=f->lp=f->buf=buf;
+	f->state=RDWR;
+	return 0;
+}
+int _IO_setvbuf(FILE *f){
+	if(f==stderr || (f==stdout && isatty(1)))
+		return setvbuf(f, (char *)0, _IOLBF, BUFSIZ);
+	return setvbuf(f, (char *)0, _IOFBF, BUFSIZ);
+}
diff --git a/sys/src/ape/lib/ap/stdio/snprintf.c b/sys/src/ape/lib/ap/stdio/snprintf.c
new file mode 100755
index 000000000..0c5c2ae8f
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/snprintf.c
@@ -0,0 +1,20 @@
+/*
+ * pANS stdio -- sprintf
+ */
+#define _C99_SNPRINTF_EXTENSION
+
+#include "iolib.h"
+
+int snprintf(char *buf, size_t nbuf, const char *fmt, ...){
+	int n;
+	va_list args;
+	FILE *f=_IO_sopenw();
+	if(f==NULL)
+		return 0;
+	setvbuf(f, buf, _IOFBF, nbuf);
+	va_start(args, fmt);
+	n=vfprintf(f, fmt, args);
+	va_end(args);
+	_IO_sclose(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/sopenr.c b/sys/src/ape/lib/ap/stdio/sopenr.c
new file mode 100755
index 000000000..279ec726b
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/sopenr.c
@@ -0,0 +1,18 @@
+/*
+ * pANS stdio -- sopenr
+ */
+#include "iolib.h"
+#include <string.h>
+
+FILE *_IO_sopenr(const char *s){
+	FILE *f;
+	for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) if(f->state==CLOSED) break;
+	if(f==&_IO_stream[FOPEN_MAX]) return NULL;
+	f->buf=f->rp=(char *)s;	/* what an annoyance const is */
+	f->bufl=strlen(s);
+	f->wp=f->buf+f->bufl;
+	f->state=RD;
+	f->flags=STRING;
+	f->fd=-1;
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/stdio/sopenw.c b/sys/src/ape/lib/ap/stdio/sopenw.c
new file mode 100755
index 000000000..d13634333
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/sopenw.c
@@ -0,0 +1,15 @@
+/*
+ * pANS stdio -- sopenw
+ */
+#include "iolib.h"
+
+FILE *_IO_sopenw(void){
+	FILE *f;
+	for(f=_IO_stream;f!=&_IO_stream[FOPEN_MAX];f++) if(f->state==CLOSED) break;
+	if(f==&_IO_stream[FOPEN_MAX]) return NULL;
+	f->buf=f->rp=f->wp=0;
+	f->state=OPEN;
+	f->flags=STRING;
+	f->fd=-1;
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/stdio/sprintf.c b/sys/src/ape/lib/ap/stdio/sprintf.c
new file mode 100755
index 000000000..5143bccf3
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/sprintf.c
@@ -0,0 +1,17 @@
+/*
+ * pANS stdio -- sprintf
+ */
+#include "iolib.h"
+int sprintf(char *buf, const char *fmt, ...){
+	int n;
+	va_list args;
+	FILE *f=_IO_sopenw();
+	if(f==NULL)
+		return 0;
+	setvbuf(f, buf, _IOFBF, 100000);
+	va_start(args, fmt);
+	n=vfprintf(f, fmt, args);
+	va_end(args);
+	_IO_sclose(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/sscanf.c b/sys/src/ape/lib/ap/stdio/sscanf.c
new file mode 100755
index 000000000..3e1d9b675
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/sscanf.c
@@ -0,0 +1,14 @@
+/*
+ * pANS stdio -- sscanf
+ */
+#include "iolib.h"
+int sscanf(const char *s, const char *fmt, ...){
+	int n;
+	FILE *f=_IO_sopenr(s);
+	va_list args;
+	va_start(args, fmt);
+	n=vfscanf(f, fmt, args);
+	va_end(args);
+	_IO_sclose(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/stdio.c b/sys/src/ape/lib/ap/stdio/stdio.c
new file mode 100755
index 000000000..854efe42b
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/stdio.c
@@ -0,0 +1,10 @@
+/*
+ * pANS stdio -- data
+ */
+#include "iolib.h"
+FILE _IO_stream[]={
+/*	fd	flags	state	buf	rp	wp	lp	bufl	unbuf */
+	0,	0,	OPEN,	0,	0,	0,	0,	0,	0,
+	1,	0,	OPEN,	0,	0,	0,	0,	0,	0,
+	2,	0,	OPEN,	0,	0,	0,	0,	0,	0,
+};
diff --git a/sys/src/ape/lib/ap/stdio/strerror.c b/sys/src/ape/lib/ap/stdio/strerror.c
new file mode 100755
index 000000000..71685d906
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/strerror.c
@@ -0,0 +1,106 @@
+/*
+ * pANS stdio -- strerror (not really in stdio)
+ *
+ * Shouldn't really call this sys_errlist or make it
+ * externally visible, but too many programs in X assume it...
+ */
+#include <string.h>
+#include <errno.h>
+
+#include "iolib.h"
+
+char *sys_errlist[] = {
+	"Error 0",
+	"Too big",
+	"Access denied",
+	"Try again",
+	"Bad file number",
+	"In use",
+	"No children",
+	"Deadlock",
+	"File exists",
+	"Bad address",
+	"File too large",
+	"Interrupted system call",
+	"Invalid argument",
+	"I/O error",
+	"Is a directory",
+	"Too many open files",
+	"Too many links",
+	"Name too long",
+	"File table overflow",
+	"No such device",
+	"No such file or directory",
+	"Exec format error",
+	"Not enough locks",
+	"Not enough memory",
+	"No space left on device",
+	"No such system call",
+	"Not a directory",
+	"Directory not empty",
+	"Inappropriate ioctl",
+	"No such device or address",
+	"Permission denied",
+	"Broken pipe",
+	"Read-only file system",
+	"Illegal seek",
+	"No such process",
+	"Cross-device link",
+
+	/* bsd networking software */
+	"Not a socket",
+	"Protocol not supported",	/* EPROTONOSUPPORT, EPROTOTYPE */
+/*	"Protocol wrong type for socket",	/* EPROTOTYPE */
+	"Connection refused",
+	"Address family not supported",
+	"No buffers",
+	"OP not supported",
+	"Address in use",
+	"Destination address required",
+	"Message size",
+	"Protocol option not supported",
+	"Socket option not supported",
+	"Protocol family not supported",	/* EPFNOSUPPORT */
+	"Address not available",
+	"Network down",
+	"Network unreachable",
+	"Network reset",
+	"Connection aborted",
+	"Connected",
+	"Not connected",
+	"Shut down",
+	"Too many references",
+	"Timed out",
+	"Host down",
+	"Host unreachable",
+	"Unknown error",		/* EGREG */
+
+	/* These added in 1003.1b-1993 */
+	"Operation canceled",
+	"Operation in progress"
+};
+#define	_IO_nerr	(sizeof sys_errlist/sizeof sys_errlist[0])
+int sys_nerr = _IO_nerr;
+extern char _plan9err[];
+
+char *
+strerror(int n)
+{
+	if(n == EPLAN9)
+		return _plan9err;
+	if(n >= 0 && n < _IO_nerr)
+		return sys_errlist[n];
+	if(n == EDOM)
+		return "Domain error";
+	else if(n == ERANGE)
+		return "Range error";
+	else
+		return "Unknown error";
+}
+
+char *
+strerror_r(int n, char *buf, int len)
+{
+	strncpy(buf, strerror(n), len);
+	buf[len-1] = 0;
+}
diff --git a/sys/src/ape/lib/ap/stdio/strtod.c b/sys/src/ape/lib/ap/stdio/strtod.c
new file mode 100755
index 000000000..ff820ef62
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/strtod.c
@@ -0,0 +1,731 @@
+#include "fconv.h"
+
+/* strtod for IEEE-, VAX-, and IBM-arithmetic machines (dmg).
+ *
+ * This strtod returns a nearest machine number to the input decimal
+ * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
+ * broken by the IEEE round-even rule.  Otherwise ties are broken by
+ * biased rounding (add half and chop).
+ *
+ * Inspired loosely by William D. Clinger's paper "How to Read Floating
+ * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *
+ *	1. We only require IEEE, IBM, or VAX double-precision
+ *		arithmetic (not IEEE double-extended).
+ *	2. We get by with floating-point arithmetic in a case that
+ *		Clinger missed -- when we're computing d * 10^n
+ *		for a small integer d and the integer n is not too
+ *		much larger than 22 (the maximum integer k for which
+ *		we can represent 10^k exactly), we may be able to
+ *		compute (d*10^k) * 10^(e-k) with just one roundoff.
+ *	3. Rather than a bit-at-a-time adjustment of the binary
+ *		result in the hard case, we use floating-point
+ *		arithmetic to determine the adjustment to within
+ *		one bit; only in really hard cases do we need to
+ *		compute a second residual.
+ *	4. Because of 3., we don't need a large table of powers of 10
+ *		for ten-to-e (just some small tables, e.g. of 10^k
+ *		for 0 <= k <= 22).
+ */
+
+#ifdef RND_PRODQUOT
+#define rounded_product(a,b) a = rnd_prod(a, b)
+#define rounded_quotient(a,b) a = rnd_quot(a, b)
+extern double rnd_prod(double, double), rnd_quot(double, double);
+#else
+#define rounded_product(a,b) a *= b
+#define rounded_quotient(a,b) a /= b
+#endif
+
+ static double
+ulp(double xarg)
+{
+	register long L;
+	Dul a;
+	Dul x;
+
+	x.d = xarg;
+	L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
+#ifndef Sudden_Underflow
+	if (L > 0) {
+#endif
+#ifdef IBM
+		L |= Exp_msk1 >> 4;
+#endif
+		word0(a) = L;
+		word1(a) = 0;
+#ifndef Sudden_Underflow
+		}
+	else {
+		L = -L >> Exp_shift;
+		if (L < Exp_shift) {
+			word0(a) = 0x80000 >> L;
+			word1(a) = 0;
+			}
+		else {
+			word0(a) = 0;
+			L -= Exp_shift;
+			word1(a) = L >= 31 ? 1 : 1 << 31 - L;
+			}
+		}
+#endif
+	return a.d;
+	}
+
+ static Bigint *
+s2b(CONST char *s, int nd0, int nd, unsigned long y9)
+{
+	Bigint *b;
+	int i, k;
+	long x, y;
+
+	x = (nd + 8) / 9;
+	for(k = 0, y = 1; x > y; y <<= 1, k++) ;
+#ifdef Pack_32
+	b = Balloc(k);
+	b->x[0] = y9;
+	b->wds = 1;
+#else
+	b = Balloc(k+1);
+	b->x[0] = y9 & 0xffff;
+	b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
+#endif
+
+	i = 9;
+	if (9 < nd0) {
+		s += 9;
+		do b = multadd(b, 10, *s++ - '0');
+			while(++i < nd0);
+		s++;
+		}
+	else
+		s += 10;
+	for(; i < nd; i++)
+		b = multadd(b, 10, *s++ - '0');
+	return b;
+	}
+
+ static double
+b2d(Bigint *a, int *e)
+{
+	unsigned long *xa, *xa0, w, y, z;
+	int k;
+	Dul d;
+#ifdef VAX
+	unsigned long d0, d1;
+#else
+#define d0 word0(d)
+#define d1 word1(d)
+#endif
+
+	xa0 = a->x;
+	xa = xa0 + a->wds;
+	y = *--xa;
+#ifdef DEBUG
+	if (!y) Bug("zero y in b2d");
+#endif
+	k = hi0bits(y);
+	*e = 32 - k;
+#ifdef Pack_32
+	if (k < Ebits) {
+		d0 = Exp_1 | y >> Ebits - k;
+		w = xa > xa0 ? *--xa : 0;
+		d1 = y << (32-Ebits) + k | w >> Ebits - k;
+		goto ret_d;
+		}
+	z = xa > xa0 ? *--xa : 0;
+	if (k -= Ebits) {
+		d0 = Exp_1 | y << k | z >> 32 - k;
+		y = xa > xa0 ? *--xa : 0;
+		d1 = z << k | y >> 32 - k;
+		}
+	else {
+		d0 = Exp_1 | y;
+		d1 = z;
+		}
+#else
+	if (k < Ebits + 16) {
+		z = xa > xa0 ? *--xa : 0;
+		d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
+		w = xa > xa0 ? *--xa : 0;
+		y = xa > xa0 ? *--xa : 0;
+		d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
+		goto ret_d;
+		}
+	z = xa > xa0 ? *--xa : 0;
+	w = xa > xa0 ? *--xa : 0;
+	k -= Ebits + 16;
+	d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
+	y = xa > xa0 ? *--xa : 0;
+	d1 = w << k + 16 | y << k;
+#endif
+ ret_d:
+#ifdef VAX
+	word0(d) = d0 >> 16 | d0 << 16;
+	word1(d) = d1 >> 16 | d1 << 16;
+#else
+#undef d0
+#undef d1
+#endif
+	return d.d;
+	}
+
+ static double
+ratio(Bigint *a, Bigint *b)
+{
+	Dul da, db;
+	int k, ka, kb;
+
+	da.d = b2d(a, &ka);
+	db.d = b2d(b, &kb);
+#ifdef Pack_32
+	k = ka - kb + 32*(a->wds - b->wds);
+#else
+	k = ka - kb + 16*(a->wds - b->wds);
+#endif
+#ifdef IBM
+	if (k > 0) {
+		word0(da) += (k >> 2)*Exp_msk1;
+		if (k &= 3)
+			da *= 1 << k;
+		}
+	else {
+		k = -k;
+		word0(db) += (k >> 2)*Exp_msk1;
+		if (k &= 3)
+			db *= 1 << k;
+		}
+#else
+	if (k > 0)
+		word0(da) += k*Exp_msk1;
+	else {
+		k = -k;
+		word0(db) += k*Exp_msk1;
+		}
+#endif
+	return da.d / db.d;
+	}
+
+ double
+strtod(CONST char *s00, char **se)
+{
+	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
+		 e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
+	CONST char *s, *s0, *s1;
+	double aadj, aadj1, adj;
+	Dul rv, rv0;
+	long L;
+	unsigned long y, z;
+	Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
+	sign = nz0 = nz = 0;
+	rv.d = 0.;
+	for(s = s00;;s++) switch(*s) {
+		case '-':
+			sign = 1;
+			/* no break */
+		case '+':
+			if (*++s)
+				goto break2;
+			/* no break */
+		case 0:
+			s = s00;
+			goto ret;
+		case '\t':
+		case '\n':
+		case '\v':
+		case '\f':
+		case '\r':
+		case ' ':
+			continue;
+		default:
+			goto break2;
+		}
+ break2:
+	if (*s == '0') {
+		nz0 = 1;
+		while(*++s == '0') ;
+		if (!*s)
+			goto ret;
+		}
+	s0 = s;
+	y = z = 0;
+	for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
+		if (nd < 9)
+			y = 10*y + c - '0';
+		else if (nd < 16)
+			z = 10*z + c - '0';
+	nd0 = nd;
+	if (c == '.') {
+		c = *++s;
+		if (!nd) {
+			for(; c == '0'; c = *++s)
+				nz++;
+			if (c > '0' && c <= '9') {
+				s0 = s;
+				nf += nz;
+				nz = 0;
+				goto have_dig;
+				}
+			goto dig_done;
+			}
+		for(; c >= '0' && c <= '9'; c = *++s) {
+ have_dig:
+			nz++;
+			if (c -= '0') {
+				nf += nz;
+				for(i = 1; i < nz; i++)
+					if (nd++ < 9)
+						y *= 10;
+					else if (nd <= DBL_DIG + 1)
+						z *= 10;
+				if (nd++ < 9)
+					y = 10*y + c;
+				else if (nd <= DBL_DIG + 1)
+					z = 10*z + c;	
+				nz = 0;
+				}
+			}
+		}
+ dig_done:
+	e = 0;
+	if (c == 'e' || c == 'E') {
+		if (!nd && !nz && !nz0) {
+			s = s00;
+			goto ret;
+			}
+		s00 = s;
+		esign = 0;
+		switch(c = *++s) {
+			case '-':
+				esign = 1;
+			case '+':
+				c = *++s;
+			}
+		if (c >= '0' && c <= '9') {
+			while(c == '0')
+				c = *++s;
+			if (c > '0' && c <= '9') {
+				e = c - '0';
+				s1 = s;
+				while((c = *++s) >= '0' && c <= '9')
+					e = 10*e + c - '0';
+				if (s - s1 > 8)
+					/* Avoid confusion from exponents
+					 * so large that e might overflow.
+					 */
+					e = 9999999;
+				if (esign)
+					e = -e;
+				}
+			else
+				e = 0;
+			}
+		else
+			s = s00;
+		}
+	if (!nd) {
+		if (!nz && !nz0)
+			s = s00;
+		goto ret;
+		}
+	e1 = e -= nf;
+
+	/* Now we have nd0 digits, starting at s0, followed by a
+	 * decimal point, followed by nd-nd0 digits.  The number we're
+	 * after is the integer represented by those digits times
+	 * 10**e */
+
+	if (!nd0)
+		nd0 = nd;
+	k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+	rv.d = y;
+	if (k > 9)
+		rv.d = tens[k - 9] * rv.d + z;
+	bd0 = 0;
+	if (nd <= DBL_DIG
+#ifndef RND_PRODQUOT
+		&& FLT_ROUNDS == 1
+#endif
+			) {
+		if (!e)
+			goto ret;
+		if (e > 0) {
+			if (e <= Ten_pmax) {
+#ifdef VAX
+				goto vax_ovfl_check;
+#else
+				/* rv = */ rounded_product(rv.d, tens[e]);
+				goto ret;
+#endif
+				}
+			i = DBL_DIG - nd;
+			if (e <= Ten_pmax + i) {
+				/* A fancier test would sometimes let us do
+				 * this for larger i values.
+				 */
+				e -= i;
+				rv.d *= tens[i];
+#ifdef VAX
+				/* VAX exponent range is so narrow we must
+				 * worry about overflow here...
+				 */
+ vax_ovfl_check:
+				word0(rv) -= P*Exp_msk1;
+				/* rv = */ rounded_product(rv.d, tens[e]);
+				if ((word0(rv) & Exp_mask)
+				 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
+					goto ovfl;
+				word0(rv) += P*Exp_msk1;
+#else
+				/* rv = */ rounded_product(rv.d, tens[e]);
+#endif
+				goto ret;
+				}
+			}
+		else if (e >= -Ten_pmax) {
+			/* rv = */ rounded_quotient(rv.d, tens[-e]);
+			goto ret;
+			}
+		}
+	e1 += nd - k;
+
+	/* Get starting approximation = rv * 10**e1 */
+
+	if (e1 > 0) {
+		if (nd0 + e1 - 1 > DBL_MAX_10_EXP)
+			goto ovfl;
+		if (i = e1 & 15)
+			rv.d *= tens[i];
+		if (e1 &= ~15) {
+			if (e1 > DBL_MAX_10_EXP) {
+ ovfl:
+				errno = ERANGE;
+				rv.d = HUGE_VAL;
+				if (bd0)
+					goto retfree;
+				goto ret;
+				}
+			if (e1 >>= 4) {
+				for(j = 0; e1 > 1; j++, e1 >>= 1)
+					if (e1 & 1)
+						rv.d *= bigtens[j];
+			/* The last multiplication could overflow. */
+				word0(rv) -= P*Exp_msk1;
+				rv.d *= bigtens[j];
+				if ((z = word0(rv) & Exp_mask)
+				 > Exp_msk1*(DBL_MAX_EXP+Bias-P))
+					goto ovfl;
+				if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
+					/* set to largest number */
+					/* (Can't trust DBL_MAX) */
+					word0(rv) = Big0;
+					word1(rv) = Big1;
+					}
+				else
+					word0(rv) += P*Exp_msk1;
+				}
+
+			}
+		}
+	else if (e1 < 0) {
+		e1 = -e1;
+		if (i = e1 & 15)
+			rv.d /= tens[i];
+		if (e1 &= ~15) {
+			e1 >>= 4;
+			if (e1 >= 1 << n_bigtens)
+				goto undfl;
+			for(j = 0; e1 > 1; j++, e1 >>= 1)
+				if (e1 & 1)
+					rv.d *= tinytens[j];
+			/* The last multiplication could underflow. */
+			rv0.d = rv.d;
+			rv.d *= tinytens[j];
+			if (rv.d == 0) {
+				rv.d = 2.*rv0.d;
+				rv.d *= tinytens[j];
+				if (rv.d == 0) {
+ undfl:
+					rv.d = 0.;
+					errno = ERANGE;
+					if (bd0)
+						goto retfree;
+					goto ret;
+					}
+				word0(rv) = Tiny0;
+				word1(rv) = Tiny1;
+				/* The refinement below will clean
+				 * this approximation up.
+				 */
+				}
+			}
+		}
+
+	/* Now the hard part -- adjusting rv to the correct value.*/
+
+	/* Put digits into bd: true value = bd * 10^e */
+
+	bd0 = s2b(s0, nd0, nd, y);
+
+	for(;;) {
+		bd = Balloc(bd0->k);
+		Bcopy(bd, bd0);
+		bb = d2b(rv.d, &bbe, &bbbits);	/* rv = bb * 2^bbe */
+		bs = i2b(1);
+
+		if (e >= 0) {
+			bb2 = bb5 = 0;
+			bd2 = bd5 = e;
+			}
+		else {
+			bb2 = bb5 = -e;
+			bd2 = bd5 = 0;
+			}
+		if (bbe >= 0)
+			bb2 += bbe;
+		else
+			bd2 -= bbe;
+		bs2 = bb2;
+#ifdef Sudden_Underflow
+#ifdef IBM
+		j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
+#else
+		j = P + 1 - bbbits;
+#endif
+#else
+		i = bbe + bbbits - 1;	/* logb(rv) */
+		if (i < Emin)	/* denormal */
+			j = bbe + (P-Emin);
+		else
+			j = P + 1 - bbbits;
+#endif
+		bb2 += j;
+		bd2 += j;
+		i = bb2 < bd2 ? bb2 : bd2;
+		if (i > bs2)
+			i = bs2;
+		if (i > 0) {
+			bb2 -= i;
+			bd2 -= i;
+			bs2 -= i;
+			}
+		if (bb5 > 0) {
+			bs = pow5mult(bs, bb5);
+			bb1 = mult(bs, bb);
+			Bfree(bb);
+			bb = bb1;
+			}
+		if (bb2 > 0)
+			bb = lshift(bb, bb2);
+		if (bd5 > 0)
+			bd = pow5mult(bd, bd5);
+		if (bd2 > 0)
+			bd = lshift(bd, bd2);
+		if (bs2 > 0)
+			bs = lshift(bs, bs2);
+		delta = diff(bb, bd);
+		dsign = delta->sign;
+		delta->sign = 0;
+		i = cmp(delta, bs);
+		if (i < 0) {
+			/* Error is less than half an ulp -- check for
+			 * special case of mantissa a power of two.
+			 */
+			if (dsign || word1(rv) || word0(rv) & Bndry_mask)
+				break;
+			delta = lshift(delta,Log2P);
+			if (cmp(delta, bs) > 0)
+				goto drop_down;
+			break;
+			}
+		if (i == 0) {
+			/* exactly half-way between */
+			if (dsign) {
+				if ((word0(rv) & Bndry_mask1) == Bndry_mask1
+				 &&  word1(rv) == 0xffffffff) {
+					/*boundary case -- increment exponent*/
+					word0(rv) = (word0(rv) & Exp_mask)
+						+ Exp_msk1
+#ifdef IBM
+						| Exp_msk1 >> 4
+#endif
+						;
+					word1(rv) = 0;
+					break;
+					}
+				}
+			else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
+ drop_down:
+				/* boundary case -- decrement exponent */
+#ifdef Sudden_Underflow
+				L = word0(rv) & Exp_mask;
+#ifdef IBM
+				if (L <  Exp_msk1)
+#else
+				if (L <= Exp_msk1)
+#endif
+					goto undfl;
+				L -= Exp_msk1;
+#else
+				L = (word0(rv) & Exp_mask) - Exp_msk1;
+#endif
+				word0(rv) = L | Bndry_mask1;
+				word1(rv) = 0xffffffff;
+#ifdef IBM
+				goto cont;
+#else
+				break;
+#endif
+				}
+#ifndef ROUND_BIASED
+			if (!(word1(rv) & LSB))
+				break;
+#endif
+			if (dsign)
+				rv.d += ulp(rv.d);
+#ifndef ROUND_BIASED
+			else {
+				rv.d -= ulp(rv.d);
+#ifndef Sudden_Underflow
+				if (rv.d == 0)
+					goto undfl;
+#endif
+				}
+#endif
+			break;
+			}
+		if ((aadj = ratio(delta, bs)) <= 2.) {
+			if (dsign)
+				aadj = aadj1 = 1.;
+			else if (word1(rv) || word0(rv) & Bndry_mask) {
+#ifndef Sudden_Underflow
+				if (word1(rv) == Tiny1 && !word0(rv))
+					goto undfl;
+#endif
+				aadj = 1.;
+				aadj1 = -1.;
+				}
+			else {
+				/* special case -- power of FLT_RADIX to be */
+				/* rounded down... */
+
+				if (aadj < 2./FLT_RADIX)
+					aadj = 1./FLT_RADIX;
+				else
+					aadj *= 0.5;
+				aadj1 = -aadj;
+				}
+			}
+		else {
+			aadj *= 0.5;
+			aadj1 = dsign ? aadj : -aadj;
+#ifdef Check_FLT_ROUNDS
+			switch(FLT_ROUNDS) {
+				case 2: /* towards +infinity */
+					aadj1 -= 0.5;
+					break;
+				case 0: /* towards 0 */
+				case 3: /* towards -infinity */
+					aadj1 += 0.5;
+				}
+#else
+			if (FLT_ROUNDS == 0)
+				aadj1 += 0.5;
+#endif
+			}
+		y = word0(rv) & Exp_mask;
+
+		/* Check for overflow */
+
+		if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
+			rv0.d = rv.d;
+			word0(rv) -= P*Exp_msk1;
+			adj = aadj1 * ulp(rv.d);
+			rv.d += adj;
+			if ((word0(rv) & Exp_mask) >=
+					Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
+				if (word0(rv0) == Big0 && word1(rv0) == Big1)
+					goto ovfl;
+				word0(rv) = Big0;
+				word1(rv) = Big1;
+				goto cont;
+				}
+			else
+				word0(rv) += P*Exp_msk1;
+			}
+		else {
+#ifdef Sudden_Underflow
+			if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
+				rv0.d = rv.d;
+				word0(rv) += P*Exp_msk1;
+				adj = aadj1 * ulp(rv.d);
+				rv.d += adj;
+#ifdef IBM
+				if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
+#else
+				if ((word0(rv) & Exp_mask) <= P*Exp_msk1)
+#endif
+					{
+					if (word0(rv0) == Tiny0
+					 && word1(rv0) == Tiny1)
+						goto undfl;
+					word0(rv) = Tiny0;
+					word1(rv) = Tiny1;
+					goto cont;
+					}
+				else
+					word0(rv) -= P*Exp_msk1;
+				}
+			else {
+				adj = aadj1 * ulp(rv.d);
+				rv.d += adj;
+				}
+#else
+			/* Compute adj so that the IEEE rounding rules will
+			 * correctly round rv + adj in some half-way cases.
+			 * If rv * ulp(rv) is denormalized (i.e.,
+			 * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
+			 * trouble from bits lost to denormalization;
+			 * example: 1.2e-307 .
+			 */
+			if (y <= (P-1)*Exp_msk1 && aadj >= 1.) {
+				aadj1 = (double)(int)(aadj + 0.5);
+				if (!dsign)
+					aadj1 = -aadj1;
+				}
+			adj = aadj1 * ulp(rv.d);
+			rv.d += adj;
+#endif
+			}
+		z = word0(rv) & Exp_mask;
+		if (y == z) {
+			/* Can we stop now? */
+			L = aadj;
+			aadj -= L;
+			/* The tolerances below are conservative. */
+			if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
+				if (aadj < .4999999 || aadj > .5000001)
+					break;
+				}
+			else if (aadj < .4999999/FLT_RADIX)
+				break;
+			}
+ cont:
+		Bfree(bb);
+		Bfree(bd);
+		Bfree(bs);
+		Bfree(delta);
+		}
+ retfree:
+	Bfree(bb);
+	Bfree(bd);
+	Bfree(bs);
+	Bfree(bd0);
+	Bfree(delta);
+ ret:
+	if (se)
+		*se = (char *)s;
+	return sign ? -rv.d : rv.d;
+	}
diff --git a/sys/src/ape/lib/ap/stdio/tmpfile.c b/sys/src/ape/lib/ap/stdio/tmpfile.c
new file mode 100755
index 000000000..751986c78
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/tmpfile.c
@@ -0,0 +1,32 @@
+/*
+ * This file not used on plan9: see ../plan9/tmpfile.c
+ */
+/*
+ * pANS stdio -- tmpfile
+ *
+ * Bug: contains a critical section.  Two executions by the same
+ * user could interleave as follows, both yielding the same file:
+ *	access fails
+ *			access fails
+ *	fopen succeeds
+ *			fopen succeeds
+ *	unlink succeeds
+ *			unlink fails
+ * As I read the pANS, this can't reasonably use tmpnam to generate
+ * the name, so that code is duplicated.
+ */
+#include "iolib.h"
+FILE *tmpfile(void){
+	FILE *f;
+	static char name[]="/tmp/tf000000000000";
+	char *p;
+	while(access(name, 0)==0){
+		p=name+7;
+		while(*p=='9') *p++='0';
+		if(*p=='\0') return NULL;
+		++*p;
+	}
+	f=fopen(name, "wb+");
+	unlink(name);
+	return f;
+}
diff --git a/sys/src/ape/lib/ap/stdio/tmpnam.c b/sys/src/ape/lib/ap/stdio/tmpnam.c
new file mode 100755
index 000000000..6ab301378
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/tmpnam.c
@@ -0,0 +1,33 @@
+/*
+ * pANS stdio -- tmpnam
+ */
+#include "iolib.h"
+#include <string.h>
+
+char *
+tmpnam(char *s)
+{
+	static char name[] = "/tmp/tn000000000000";
+	char *p;
+
+	do {
+		p = name + 7;
+		while (*p == '9')
+			*p++ = '0';
+		if (*p == '\0')
+			return NULL;
+		++*p;
+	} while (access(name, 0) == 0);
+	if (s) {
+		strcpy(s, name);
+		return s;
+	}
+	return name;
+}
+
+
+char *
+tmpnam_r(char *s)
+{
+	return s ? tmpnam(s) : NULL;
+}
diff --git a/sys/src/ape/lib/ap/stdio/ungetc.c b/sys/src/ape/lib/ap/stdio/ungetc.c
new file mode 100755
index 000000000..3c071690b
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/ungetc.c
@@ -0,0 +1,33 @@
+/*
+ * pANS stdio -- ungetc
+ */
+#include "iolib.h"
+int ungetc(int c, FILE *f){
+	if(c==EOF) return EOF;
+	switch(f->state){
+	default:	/* WR */
+		f->state=ERR;
+		return EOF;
+	case CLOSED:
+	case ERR:
+		return EOF;
+	case OPEN:
+		_IO_setvbuf(f);
+	case RDWR:
+	case END:
+		f->wp=f->buf;
+		if(f->bufl==0)
+			f->wp += 1;
+		else
+			f->wp += f->bufl;
+		f->rp = f->wp;
+		f->state=RD;
+	case RD:
+		if(f->rp==f->buf) return EOF;
+		if(f->flags&STRING)
+			f->rp--;
+		else
+			*--f->rp=c;
+		return (char)c;
+	}
+}
diff --git a/sys/src/ape/lib/ap/stdio/vfprintf.c b/sys/src/ape/lib/ap/stdio/vfprintf.c
new file mode 100755
index 000000000..dc8c406ff
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/vfprintf.c
@@ -0,0 +1,566 @@
+/*
+ * pANS stdio -- vfprintf
+ */
+#include "iolib.h"
+#include <stdarg.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+/*
+ * Leading flags
+ */
+#define	SPACE	1		/* ' ' prepend space if no sign printed */
+#define	ALT	2		/* '#' use alternate conversion */
+#define	SIGN	4		/* '+' prepend sign, even if positive */
+#define	LEFT	8		/* '-' left-justify */
+#define	ZPAD	16		/* '0' zero-pad */
+/*
+ * Trailing flags
+ */
+#define	SHORT	32		/* 'h' convert a short integer */
+#define	LONG	64		/* 'l' convert a long integer */
+#define	LDBL	128		/* 'L' convert a long double */
+#define	PTR	256		/*     convert a void * (%p) */
+#define	VLONG	512		/* 'll' convert a long long integer */
+
+static int lflag[] = {	/* leading flags */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^@ ^A ^B ^C ^D ^E ^F ^G */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^H ^I ^J ^K ^L ^M ^N ^O */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^P ^Q ^R ^S ^T ^U ^V ^W */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+SPACE,	0,	0,	ALT,	0,	0,	0,	0,	/* sp  !  "  #  $  %  &  ' */
+0,	0,	0,	SIGN,	0,	LEFT,	0,	0,	/*  (  )  *  +  ,  -  .  / */
+ZPAD,	0,	0,	0,	0,	0,	0,	0,	/*  0  1  2  3  4  5  6  7 */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  8  9  :  ;  <  =  >  ? */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  @  A  B  C  D  E  F  G */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  H  I  J  K  L  M  N  O */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  P  Q  R  S  T  U  V  W */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  X  Y  Z  [  \  ]  ^  _ */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  `  a  b  c  d  e  f  g */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  h  i  j  k  l  m  n  o */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  p  q  r  s  t  u  v  w */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  x  y  z  {  |  }  ~ ^? */
+
+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,	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,	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,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+};
+
+static int tflag[] = {	/* trailing flags */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^@ ^A ^B ^C ^D ^E ^F ^G */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^H ^I ^J ^K ^L ^M ^N ^O */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^P ^Q ^R ^S ^T ^U ^V ^W */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+0,	0,	0,	0,	0,	0,	0,	0,	/* sp  !  "  #  $  %  &  ' */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  (  )  *  +  ,  -  .  / */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  0  1  2  3  4  5  6  7 */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  8  9  :  ;  <  =  >  ? */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  @  A  B  C  D  E  F  G */
+0,	0,	0,	0,	LDBL,	0,	0,	0,	/*  H  I  J  K  L  M  N  O */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  P  Q  R  S  T  U  V  W */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  X  Y  Z  [  \  ]  ^  _ */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  `  a  b  c  d  e  f  g */
+SHORT,	0,	0,	0,	LONG,	0,	0,	0,	/*  h  i  j  k  l  m  n  o */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  p  q  r  s  t  u  v  w */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  x  y  z  {  |  }  ~ ^? */
+
+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,	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,	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,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+};
+
+static int ocvt_E(FILE *, va_list *, int, int, int);
+static int ocvt_G(FILE *, va_list *, int, int, int);
+static int ocvt_X(FILE *, va_list *, int, int, int);
+static int ocvt_c(FILE *, va_list *, int, int, int);
+static int ocvt_d(FILE *, va_list *, int, int, int);
+static int ocvt_e(FILE *, va_list *, int, int, int);
+static int ocvt_f(FILE *, va_list *, int, int, int);
+static int ocvt_g(FILE *, va_list *, int, int, int);
+static int ocvt_n(FILE *, va_list *, int, int, int);
+static int ocvt_o(FILE *, va_list *, int, int, int);
+static int ocvt_p(FILE *, va_list *, int, int, int);
+static int ocvt_s(FILE *, va_list *, int, int, int);
+static int ocvt_u(FILE *, va_list *, int, int, int);
+static int ocvt_x(FILE *, va_list *, int, int, int);
+
+static int(*ocvt[])(FILE *, va_list *, int, int, int) = {
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^@ ^A ^B ^C ^D ^E ^F ^G */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^H ^I ^J ^K ^L ^M ^N ^O */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^P ^Q ^R ^S ^T ^U ^V ^W */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+0,	0,	0,	0,	0,	0,	0,	0,	/* sp  !  "  #  $  %  &  ' */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  (  )  *  +  ,  -  .  / */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  0  1  2  3  4  5  6  7 */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  8  9  :  ;  <  =  >  ? */
+0,	0,	0,	0,	0,	ocvt_E,	0,	ocvt_G,	/*  @  A  B  C  D  E  F  G */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  H  I  J  K  L  M  N  O */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  P  Q  R  S  T  U  V  W */
+ocvt_X,	0,	0,	0,	0,	0,	0,	0,	/*  X  Y  Z  [  \  ]  ^  _ */
+0,	0,	0,	ocvt_c,	ocvt_d,	ocvt_e,	ocvt_f,	ocvt_g,	/*  `  a  b  c  d  e  f  g */
+0,	ocvt_d,	0,	0,	0,	0,	ocvt_n,	ocvt_o,	/*  h  i  j  k  l  m  n  o */
+ocvt_p,	0,	0,	ocvt_s,	0,	ocvt_u,	0,	0,	/*  p  q  r  s  t  u  v  w */
+ocvt_x,	0,	0,	0,	0,	0,	0,	0,	/*  x  y  z  {  |  }  ~ ^? */
+
+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,	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,	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,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+};
+
+static int nprint;
+
+int
+vfprintf(FILE *f, const char *s, va_list args)
+{
+	int tfl, flags, width, precision;
+
+	nprint = 0;
+	while(*s){
+		if(*s != '%'){
+			putc(*s++, f);
+			nprint++;
+			continue;
+		}
+		s++;
+		flags = 0;
+		while(lflag[*s&_IO_CHMASK]) flags |= lflag[*s++&_IO_CHMASK];
+		if(*s == '*'){
+			width = va_arg(args, int);
+			s++;
+			if(width<0){
+				flags |= LEFT;
+				width = -width;
+			}
+		}
+		else{
+			width = 0;
+			while('0'<=*s && *s<='9') width = width*10 + *s++ - '0';
+		}
+		if(*s == '.'){
+			s++;
+			if(*s == '*'){
+				precision = va_arg(args, int);
+				s++;
+			}
+			else{
+				precision = 0;
+				while('0'<=*s && *s<='9') precision = precision*10 + *s++ - '0';
+			}
+		}
+		else
+			precision = -1;
+		while(tfl = tflag[*s&_IO_CHMASK]){
+			if(tfl == LONG && (flags & LONG)){
+				flags &= ~LONG;
+				tfl = VLONG;
+			}
+			flags |= tfl;
+			s++;
+		}
+		if(ocvt[*s]) nprint += (*ocvt[*s++])(f, &args, flags, width, precision);
+		else if(*s){
+			putc(*s++, f);
+			nprint++;
+		}
+	}
+	return ferror(f)? -1: nprint;;
+}
+
+static int
+ocvt_c(FILE *f, va_list *args, int flags, int width, int precision)
+{
+#pragma ref precision
+	int i;
+
+	if(!(flags&LEFT)) for(i=1; i<width; i++) putc(' ', f);
+	putc((unsigned char)va_arg(*args, int), f);
+	if(flags&LEFT) for(i=1; i<width; i++) putc(' ', f);
+	return width<1 ? 1 : width;
+}
+
+static int
+ocvt_s(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	int i, n = 0;
+	char *s;
+
+	s = va_arg(*args, char *);
+	if(!s)
+		s = "";
+	if(!(flags&LEFT)){
+		if(precision >= 0)
+			for(i=0; i!=precision && s[i]; i++);
+		else
+			for(i=0; s[i]; i++);
+		for(; i<width; i++){
+			putc(' ', f);
+			n++;
+		}
+	}
+	if(precision >= 0){
+		for(i=0; i!=precision && *s; i++){
+			putc(*s++, f);
+			n++;
+		}
+	} else{
+		for(i=0;*s;i++){
+			putc(*s++, f);
+			n++;
+		}
+	}
+	if(flags&LEFT){
+		for(; i<width; i++){
+			putc(' ', f);
+			n++;
+		}
+	}
+	return n;
+}
+
+static int
+ocvt_n(FILE *f, va_list *args, int flags, int width, int precision)
+{
+#pragma ref f
+#pragma ref width
+#pragma ref precision
+	if(flags&SHORT)
+		*va_arg(*args, short *) = nprint;
+	else if(flags&LONG)
+		*va_arg(*args, long *) = nprint;
+	else if(flags&VLONG)
+		*va_arg(*args, long long*) = nprint;
+	else
+		*va_arg(*args, int *) = nprint;
+	return 0;
+}
+
+/*
+ * Generic fixed-point conversion
+ *	f is the output FILE *;
+ *	args is the va_list * from which to get the number;
+ *	flags, width and precision are the results of printf-cracking;
+ *	radix is the number base to print in;
+ *	alphabet is the set of digits to use;
+ *	prefix is the prefix to print before non-zero numbers when
+ *	using ``alternate form.''
+ */
+static int
+ocvt_fixed(FILE *f, va_list *args, int flags, int width, int precision,
+	int radix, int sgned, char alphabet[], char *prefix)
+{
+	char digits[128];	/* no reasonable machine will ever overflow this */
+	char *sign;
+	char *dp;
+	long long snum;
+	unsigned long long num;
+	int nout, npad, nlzero;
+
+	if(sgned){
+		if(flags&PTR) snum = (long)va_arg(*args, void *);
+		else if(flags&SHORT) snum = va_arg(*args, short);
+		else if(flags&LONG) snum = va_arg(*args, long);
+		else if(flags&VLONG) snum = va_arg(*args, long long);
+		else snum = va_arg(*args, int);
+		if(snum < 0){
+			sign = "-";
+			num = -snum;
+		} else{
+			if(flags&SIGN) sign = "+";
+			else if(flags&SPACE) sign = " ";
+			else sign = "";
+			num = snum;
+		}
+	} else {
+		sign = "";
+		if(flags&PTR) num = (long)va_arg(*args, void *);
+		else if(flags&SHORT) num = va_arg(*args, unsigned short);
+		else if(flags&LONG) num = va_arg(*args, unsigned long);
+		else if(flags&VLONG) num = va_arg(*args, unsigned long long);
+		else num = va_arg(*args, unsigned int);
+	}
+	if(num == 0) prefix = "";
+	dp = digits;
+	do{
+		*dp++ = alphabet[num%radix];
+		num /= radix;
+	}while(num);
+	if(precision==0 && dp-digits==1 && dp[-1]=='0')
+		dp--;
+	nlzero = precision-(dp-digits);
+	if(nlzero < 0) nlzero = 0;
+	if(flags&ALT){
+		if(radix == 8) if(dp[-1]=='0' || nlzero) prefix = "";
+	}
+	else prefix = "";
+	nout = dp-digits+nlzero+strlen(prefix)+strlen(sign);
+	npad = width-nout;
+	if(npad < 0) npad = 0;
+	nout += npad;
+	if(!(flags&LEFT)){
+		if(flags&ZPAD && precision <= 0){
+			fputs(sign, f);
+			fputs(prefix, f);
+			while(npad){
+				putc('0', f);
+				--npad;
+			}
+		} else{
+			while(npad){
+				putc(' ', f);
+				--npad;
+			}
+			fputs(sign, f);
+			fputs(prefix, f);
+		}
+		while(nlzero){
+			putc('0', f);
+			--nlzero;
+		}
+		while(dp!=digits) putc(*--dp, f);
+	}
+	else{
+		fputs(sign, f);
+		fputs(prefix, f);
+		while(nlzero){
+			putc('0', f);
+			--nlzero;
+		}
+		while(dp != digits) putc(*--dp, f);
+		while(npad){
+			putc(' ', f);
+			--npad;
+		}
+	}
+	return nout;	
+}
+
+static int
+ocvt_X(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags, width, precision, 16, 0, "0123456789ABCDEF", "0X");
+}
+
+static int
+ocvt_d(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags, width, precision, 10, 1, "0123456789", "");
+}
+
+static int
+ocvt_o(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags, width, precision, 8, 0, "01234567", "0");
+}
+
+static int
+ocvt_p(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags|PTR|ALT, width, precision, 16, 0,
+		"0123456789ABCDEF", "0x");
+}
+
+static int
+ocvt_u(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags, width, precision, 10, 0, "0123456789", "");
+}
+
+static int
+ocvt_x(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_fixed(f, args, flags, width, precision, 16, 0, "0123456789abcdef", "0x");
+}
+
+static int ocvt_flt(FILE *, va_list *, int, int, int, char);
+
+static int
+ocvt_E(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_flt(f, args, flags, width, precision, 'E');
+}
+
+static int
+ocvt_G(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_flt(f, args, flags, width, precision, 'G');
+}
+
+static int
+ocvt_e(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_flt(f, args, flags, width, precision, 'e');
+}
+
+static int
+ocvt_f(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_flt(f, args, flags, width, precision, 'f');
+}
+
+static int
+ocvt_g(FILE *f, va_list *args, int flags, int width, int precision)
+{
+	return ocvt_flt(f, args, flags, width, precision, 'g');
+}
+
+static int
+ocvt_flt(FILE *f, va_list *args, int flags, int width, int precision, char afmt)
+{
+	extern char *_dtoa(double, int, int, int*, int*, char **);
+	int echr;
+	char *digits, *edigits;
+	int exponent;
+	char fmt;
+	int sign;
+	int ndig;
+	int nout, i;
+	char ebuf[20];	/* no sensible machine will overflow this */
+	char *eptr;
+	double d;
+
+	echr = 'e';
+	fmt = afmt;
+	d = va_arg(*args, double);
+	if(precision < 0) precision = 6;
+	switch(fmt){
+	case 'f':
+		digits = _dtoa(d, 3, precision, &exponent, &sign, &edigits);
+		break;
+	case 'E':
+		echr = 'E';
+		fmt = 'e';
+		/* fall through */
+	case 'e':
+		digits = _dtoa(d, 2, 1+precision, &exponent, &sign, &edigits);
+		break;
+	case 'G':
+		echr = 'E';
+		/* fall through */
+	case 'g':
+		if (precision > 0)
+			digits = _dtoa(d, 2, precision, &exponent, &sign, &edigits);
+		else {
+			digits = _dtoa(d, 0, precision, &exponent, &sign, &edigits);
+			precision = edigits - digits;
+			if (exponent > precision && exponent <= precision + 4)
+				precision = exponent;
+			}
+		if(exponent >= -3 && exponent <= precision){
+			fmt = 'f';
+			precision -= exponent;
+		}else{
+			fmt = 'e';
+			--precision;
+		}
+		break;
+	}
+	if (exponent == 9999) {
+		/* Infinity or Nan */
+		precision = 0;
+		exponent = edigits - digits;
+		fmt = 'f';
+	}
+	ndig = edigits-digits;
+	if(ndig == 0) {
+		ndig = 1;
+		digits = "0";
+	}
+	if((afmt=='g' || afmt=='G') && !(flags&ALT)){	/* knock off trailing zeros */
+		if(fmt == 'f'){
+			if(precision+exponent > ndig) {
+				precision = ndig - exponent;
+				if(precision < 0)
+					precision = 0;
+			}
+		}
+		else{
+			if(precision > ndig-1) precision = ndig-1;
+		}
+	}
+	nout = precision;				/* digits after decimal point */
+	if(precision!=0 || flags&ALT) nout++;		/* decimal point */
+	if(fmt=='f' && exponent>0) nout += exponent;	/* digits before decimal point */
+	else nout++;					/* there's always at least one */
+	if(sign || flags&(SPACE|SIGN)) nout++;		/* sign */
+	if(fmt != 'f'){					/* exponent */
+		eptr = ebuf;
+		for(i=exponent<=0?1-exponent:exponent-1; i; i/=10)
+			*eptr++ = '0' + i%10;
+		while(eptr<ebuf+2) *eptr++ = '0';
+		nout += eptr-ebuf+2;			/* e+99 */
+	}
+	if(!(flags&ZPAD) && !(flags&LEFT))
+		while(nout < width){
+			putc(' ', f);
+			nout++;
+		}
+	if(sign) putc('-', f);
+	else if(flags&SIGN) putc('+', f);
+	else if(flags&SPACE) putc(' ', f);
+	if((flags&ZPAD) && !(flags&LEFT))
+		while(nout < width){
+			putc('0', f);
+			nout++;
+		}
+	if(fmt == 'f'){
+		for(i=0; i<exponent; i++) putc(i<ndig?digits[i]:'0', f);
+		if(i == 0) putc('0', f);
+		if(precision>0 || flags&ALT) putc('.', f);
+		for(i=0; i!=precision; i++)
+			putc(0<=i+exponent && i+exponent<ndig?digits[i+exponent]:'0', f);
+	}
+	else{
+		putc(digits[0], f);
+		if(precision>0 || flags&ALT) putc('.', f);
+		for(i=0; i!=precision; i++) putc(i<ndig-1?digits[i+1]:'0', f);
+	}
+	if(fmt != 'f'){
+		putc(echr, f);
+		putc(exponent<=0?'-':'+', f);
+		while(eptr>ebuf) putc(*--eptr, f);
+	}
+	while(nout < width){
+		putc(' ', f);
+		nout++;
+	}
+	return nout;
+}
diff --git a/sys/src/ape/lib/ap/stdio/vfscanf.c b/sys/src/ape/lib/ap/stdio/vfscanf.c
new file mode 100755
index 000000000..14a55956c
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/vfscanf.c
@@ -0,0 +1,367 @@
+/*
+ * pANS stdio -- vfscanf
+ */
+#include "iolib.h"
+#include <stdarg.h>
+#include <math.h>
+#include <stdlib.h>
+#include <ctype.h>
+static int icvt_f(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_x(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_sq(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_c(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_d(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_i(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_n(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_o(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_p(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_s(FILE *f, va_list *args, int store, int width, int type);
+static int icvt_u(FILE *f, va_list *args, int store, int width, int type);
+static int (*icvt[])(FILE *, va_list *, int, int, int)={
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^@ ^A ^B ^C ^D ^E ^F ^G */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^H ^I ^J ^K ^L ^M ^N ^O */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^P ^Q ^R ^S ^T ^U ^V ^W */
+0,	0,	0,	0,	0,	0,	0,	0,	/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+0,	0,	0,	0,	0,	0,	0,	0,	/* sp  !  "  #  $  %  &  ' */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  (  )  *  +  ,  -  .  / */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  0  1  2  3  4  5  6  7 */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  8  9  :  ;  <  =  >  ? */
+0,	0,	0,	0,	0,	icvt_f,	0,	icvt_f,	/*  @  A  B  C  D  E  F  G */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  H  I  J  K  L  M  N  O */
+0,	0,	0,	0,	0,	0,	0,	0,	/*  P  Q  R  S  T  U  V  W */
+icvt_x,	0,	0,	icvt_sq,0,	0,	0,	0,	/*  X  Y  Z  [  \  ]  ^  _ */
+0,	0,	0,	icvt_c,	icvt_d,	icvt_f,	icvt_f,	icvt_f,	/*  `  a  b  c  d  e  f  g */
+0,	icvt_i,	0,	0,	0,	0,	icvt_n,	icvt_o,	/*  h  i  j  k  l  m  n  o */
+icvt_p,	0,	0,	icvt_s,	0,	icvt_u,	0,	0,	/*  p  q  r  s  t  u  v  w */
+icvt_x,	0,	0,	0,	0,	0,	0,	0,	/*  x  y  z  {  |  }  ~ ^? */
+
+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,	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,	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,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+0,	0,	0,	0,	0,	0,	0,	0,
+
+};
+#define	ngetc(f)		(nread++, getc(f))
+#define	nungetc(c, f)		(--nread, ungetc((c), f))
+#define	wgetc(c, f, out)	if(width--==0) goto out; (c)=ngetc(f)
+#define	wungetc(c, f)		(++width, nungetc(c, f))
+static int nread, ncvt;
+static const char *fmtp;
+
+int vfscanf(FILE *f, const char *s, va_list args){
+	int c, width, type, store;
+	nread=0;
+	ncvt=0;
+	fmtp=s;
+	for(;*fmtp;fmtp++) switch(*fmtp){
+	default:
+		if(isspace(*fmtp)){
+			do
+				c=ngetc(f);
+			while(isspace(c));
+			if(c==EOF) return ncvt?ncvt:EOF;
+			nungetc(c, f);
+			break;
+		}
+	NonSpecial:
+		c=ngetc(f);
+		if(c==EOF) return ncvt?ncvt:EOF;
+		if(c!=*fmtp){
+			nungetc(c, f);
+			return ncvt;
+		}
+		break;
+	case '%':
+		fmtp++;
+		if(*fmtp!='*') store=1;
+		else{
+			store=0;
+			fmtp++;
+		}
+		if('0'<=*fmtp && *fmtp<='9'){
+			width=0;
+			while('0'<=*fmtp && *fmtp<='9') width=width*10 + *fmtp++ - '0';
+		}
+		else
+			width=-1;
+		type=*fmtp=='h' || *fmtp=='l' || *fmtp=='L'?*fmtp++:'n';
+		if(!icvt[*fmtp]) goto NonSpecial;
+		if(!(*icvt[*fmtp])(f, &args, store, width, type))
+			return ncvt?ncvt:EOF;
+		if(*fmtp=='\0') break;
+		if(store) ncvt++;
+	}
+	return ncvt;	
+}
+static int icvt_n(FILE *f, va_list *args, int store, int width, int type){
+#pragma ref f
+#pragma ref width
+	if(store){
+		--ncvt;	/* this assignment doesn't count! */
+		switch(type){
+		case 'h': *va_arg(*args, short *)=nread; break;
+		case 'n': *va_arg(*args, int *)=nread; break;
+		case 'l':
+		case 'L': *va_arg(*args, long *)=nread; break;
+		}
+	}
+	return 1;
+}
+#define	SIGNED		1
+#define	UNSIGNED	2
+#define	POINTER		3
+/*
+ * Generic fixed-point conversion
+ *	f is the input FILE *;
+ *	args is the va_list * into which to store the number;
+ *	store is a flag to enable storing;
+ *	width is the maximum field width;
+ *	type is 'h' 'l' or 'L', the scanf type modifier;
+ *	unsgned is SIGNED, UNSIGNED or POINTER, giving part of the type to store in;
+ *	base is the number base -- if 0, C number syntax is used.
+ */
+static int icvt_fixed(FILE *f, va_list *args,
+				int store, int width, int type, int unsgned, int base){
+	unsigned long int num=0;
+	int sign=1, ndig=0, dig;
+	int c;
+	do
+		c=ngetc(f);
+	while(isspace(c));
+	if(width--==0){
+		nungetc(c, f);
+		goto Done;
+	}
+	if(c=='+'){
+		wgetc(c, f, Done);
+	}
+	else if(c=='-'){
+		sign=-1;
+		wgetc(c, f, Done);
+	}
+	switch(base){
+	case 0:
+		if(c=='0'){
+			wgetc(c, f, Done);
+			if(c=='x' || c=='X'){
+				wgetc(c, f, Done);
+				base=16;
+			}
+			else{
+				ndig=1;
+				base=8;
+			}
+		}
+		else
+			base=10;
+		break;
+	case 16:
+		if(c=='0'){
+			wgetc(c, f, Done);
+			if(c=='x' || c=='X'){
+				wgetc(c, f, Done);
+			}
+			else ndig=1;
+		}
+		break;
+	}
+	while('0'<=c && c<='9' || 'a'<=c && c<='f' || 'A'<=c && c<='F'){
+		dig='0'<=c && c<='9'?c-'0':'a'<=c && c<='f'?c-'a'+10:c-'A'+10;
+		if(dig>=base) break;
+		ndig++;
+		num=num*base+dig;
+		wgetc(c, f, Done);
+	}
+	nungetc(c, f);
+Done:
+	if(ndig==0) return 0;
+	if(store){
+		switch(unsgned){
+		case SIGNED:
+			switch(type){
+			case 'h': *va_arg(*args,  short *)=num*sign; break;
+			case 'n': *va_arg(*args,  int *)=num*sign; break;
+			case 'l':
+			case 'L': *va_arg(*args,  long *)=num*sign; break;
+			}
+			break;
+		case UNSIGNED:
+			switch(type){
+			case 'h': *va_arg(*args, unsigned short *)=num*sign; break;
+			case 'n': *va_arg(*args, unsigned int *)=num*sign; break;
+			case 'l':
+			case 'L': *va_arg(*args, unsigned long *)=num*sign; break;
+			}
+			break;
+		case POINTER:
+			*va_arg(*args, void **)=(void *)(num*sign); break;
+		}
+	}
+	return 1;
+}
+static int icvt_d(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, SIGNED, 10);
+}
+static int icvt_x(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, UNSIGNED, 16);
+}
+static int icvt_o(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, UNSIGNED, 8);
+}
+static int icvt_i(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, SIGNED, 0);
+}
+static int icvt_u(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, UNSIGNED, 10);
+}
+static int icvt_p(FILE *f, va_list *args, int store, int width, int type){
+	return icvt_fixed(f, args, store, width, type, POINTER, 16);
+}
+#define	NBUF	509
+static int icvt_f(FILE *f, va_list *args, int store, int width, int type){
+	char buf[NBUF+1];
+	char *s=buf;
+	int c, ndig=0, ndpt=0, nexp=1;
+	if(width<0 || NBUF<width) width=NBUF;	/* bug -- no limit specified in ansi */
+	do
+		c=ngetc(f);
+	while(isspace(c));
+	if(width--==0){
+		nungetc(c, f);
+		goto Done;
+	}
+	if(c=='+' || c=='-'){
+		*s++=c;
+		wgetc(c, f, Done);
+	}
+	while('0'<=c && c<='9' || ndpt==0 && c=='.'){
+		if(c=='.') ndpt++;
+		else ndig++;
+		*s++=c;
+		wgetc(c, f, Done);
+	}
+	if(c=='e' || c=='E'){
+		*s++=c;
+		nexp=0;
+		wgetc(c, f, Done);
+		if(c=='+' || c=='-'){
+			*s++=c;
+			wgetc(c, f, Done);
+		}
+		while('0'<=c && c<='9'){
+			*s++=c;
+			nexp++;
+			wgetc(c, f, Done);
+		}
+	}
+	nungetc(c, f);
+Done:
+	if(ndig==0 || nexp==0) return 0;
+	*s='\0';
+	if(store) switch(type){
+	case 'h':
+	case 'n': *va_arg(*args, float *)=atof(buf); break;
+	case 'L': /* bug -- should store in a long double */
+	case 'l': *va_arg(*args, double *)=atof(buf); break;
+	}
+	return 1;
+}
+static int icvt_s(FILE *f, va_list *args, int store, int width, int type){
+#pragma ref type
+	int c, nn;
+	register char *s;
+	if(store) s=va_arg(*args, char *);
+	do
+		c=ngetc(f);
+	while(isspace(c));
+	if(width--==0){
+		nungetc(c, f);
+		goto Done;
+	}
+	nn=0;
+	while(!isspace(c)){
+		if(c==EOF){
+			nread--;
+			if(nn==0) return 0;
+			else goto Done;
+		}
+		nn++;
+		if(store) *s++=c;
+		wgetc(c, f, Done);
+	}
+	nungetc(c, f);
+Done:
+	if(store) *s='\0';
+	return 1;
+}
+static int icvt_c(FILE *f, va_list *args, int store, int width, int type){
+#pragma ref type
+	int c;
+	register char *s;
+	if(store) s=va_arg(*args, char *);
+	if(width<0) width=1;
+	for(;;){
+		wgetc(c, f, Done);
+		if(c==EOF) return 0;
+		if(store) *s++=c;
+	}
+Done:
+	return 1;
+}
+static int match(int c, const char *pat){
+	int ok=1;
+	if(*pat=='^'){
+		ok=!ok;
+		pat++;
+	}
+	while(pat!=fmtp){
+		if(pat+2<fmtp && pat[1]=='-'){
+			if(pat[0]<=c && c<=pat[2]
+			|| pat[2]<=c && c<=pat[0])
+				return ok;
+			pat+=2;
+		}
+		else if(c==*pat) return ok;
+		pat++;
+	}
+	return !ok;
+}
+static int icvt_sq(FILE *f, va_list *args, int store, int width, int type){
+#pragma ref type
+	int c, nn;
+	register char *s;
+	register const char *pat;
+	pat=++fmtp;
+	if(*fmtp=='^') fmtp++;
+	if(*fmtp!='\0') fmtp++;
+	while(*fmtp!='\0' && *fmtp!=']') fmtp++;
+	if(store) s=va_arg(*args, char *);
+	nn=0;
+	for(;;){
+		wgetc(c, f, Done);
+		if(c==EOF){
+			nread--;
+			if(nn==0) return 0;
+			else goto Done;
+		}
+		if(!match(c, pat)) break;
+		if(store) *s++=c;
+		nn++;
+	}
+	nungetc(c, f);
+Done:
+	if(store) *s='\0';
+	return 1;
+}
diff --git a/sys/src/ape/lib/ap/stdio/vprintf.c b/sys/src/ape/lib/ap/stdio/vprintf.c
new file mode 100755
index 000000000..6576219eb
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/vprintf.c
@@ -0,0 +1,7 @@
+/*
+ * pANS stdio -- vprintf
+ */
+#include "iolib.h"
+int vprintf(const char *fmt, va_list args){
+	return vfprintf(stdout, fmt, args);
+}
diff --git a/sys/src/ape/lib/ap/stdio/vsnprintf.c b/sys/src/ape/lib/ap/stdio/vsnprintf.c
new file mode 100755
index 000000000..45830fffb
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/vsnprintf.c
@@ -0,0 +1,17 @@
+/*
+ * pANS stdio -- vsnprintf
+ */
+#define _C99_SNPRINTF_EXTENSION
+
+#include "iolib.h"
+
+int vsnprintf(char *buf, size_t nbuf, const char *fmt, va_list args){
+	int n;
+	FILE *f=_IO_sopenw();
+	if(f==NULL)
+		return 0;
+	setvbuf(f, buf, _IOFBF, nbuf);
+	n=vfprintf(f, fmt, args);
+	_IO_sclose(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/stdio/vsprintf.c b/sys/src/ape/lib/ap/stdio/vsprintf.c
new file mode 100755
index 000000000..7b3fe6ec4
--- /dev/null
+++ b/sys/src/ape/lib/ap/stdio/vsprintf.c
@@ -0,0 +1,14 @@
+/*
+ * pANS stdio -- vsprintf
+ */
+#include "iolib.h"
+int vsprintf(char *buf, const char *fmt, va_list args){
+	int n;
+	FILE *f=_IO_sopenw();
+	if(f==NULL)
+		return 0;
+	setvbuf(f, buf, _IOFBF, 100000);
+	n=vfprintf(f, fmt, args);
+	_IO_sclose(f);
+	return n;
+}
diff --git a/sys/src/ape/lib/ap/syscall/genall b/sys/src/ape/lib/ap/syscall/genall
new file mode 100755
index 000000000..5aa992b95
--- /dev/null
+++ b/sys/src/ape/lib/ap/syscall/genall
@@ -0,0 +1,16 @@
+#!/bin/rc
+# genall - generate the APE versions of the system call C interfaces.
+#	must be invoked by mk so that the right env variables are set.
+rfork e
+# ugh. sources's build process can't hack absolute path names.
+# we're in /sys/src/ape/lib/ap/syscall.
+SYSH=../../../../libc/9syscall/sys.h	# /sys/src/libc/9syscall/sys.h
+
+SYS=`{sed '/^#define._/d; s/#define.([A-Z0-9_]*).*/\1/' $SYSH}
+for(I in $SYS) {
+	i=_^$I
+	n=`{sed -n '/[ 	]'$I'[ 	]/s/.*	//p' $SYSH}
+	gencall
+}
+ar vu /$objtype/lib/ape/libap.a *.$O
+rm -f *.$O *.s
diff --git a/sys/src/ape/lib/ap/syscall/mkfile b/sys/src/ape/lib/ap/syscall/mkfile
new file mode 100755
index 000000000..080839d9a
--- /dev/null
+++ b/sys/src/ape/lib/ap/syscall/mkfile
@@ -0,0 +1,25 @@
+NPROC=1
+</$objtype/mkfile
+
+all:V: install
+
+install:V: genall gencall
+	genall
+
+# ugh. sources's build process can't hack absolute path names.
+# we're in /sys/src/ape/lib/ap/syscall.
+gencall:D: ../../../../libc/9syscall/mkfile	# /sys/src/libc/9syscall/mkfile
+	{
+		echo '#!/bin/rc'
+		sed -n -e 's/seek/_SEEK/g' -e '/switch/,/\$AS /p' $prereq
+	} >$target
+	chmod +x $target
+
+nuke clean:V:
+	rm -f *.[$OS] *.s gencall
+
+installall:V:
+	for(objtype in $CPUS) mk install
+
+update:V:
+	update $UPDATEFLAGS mkfile
diff --git a/sys/src/ape/lib/bsd/_sock_ingetaddr.c b/sys/src/ape/lib/bsd/_sock_ingetaddr.c
new file mode 100755
index 000000000..bc9f90512
--- /dev/null
+++ b/sys/src/ape/lib/bsd/_sock_ingetaddr.c
@@ -0,0 +1,47 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include "priv.h"
+
+void
+_sock_ingetaddr(Rock *r, struct sockaddr_in *ip, int *alen, char *a)
+{
+	int n, fd;
+	char *p;
+	char name[Ctlsize];
+
+	/* get remote address */
+	strcpy(name, r->ctl);
+	p = strrchr(name, '/');
+	strcpy(p+1, a);
+	fd = open(name, O_RDONLY);
+	if(fd >= 0){
+		n = read(fd, name, sizeof(name)-1);
+		if(n > 0){
+			name[n] = 0;
+			p = strchr(name, '!');
+			if(p){
+				*p++ = 0;
+				ip->sin_family = AF_INET;
+				ip->sin_port = atoi(p);
+				ip->sin_addr.s_addr = inet_addr(name);
+				if(alen)
+					*alen = sizeof(struct sockaddr_in);
+			}
+		}
+		close(fd);
+	}
+
+}
diff --git a/sys/src/ape/lib/bsd/_sock_ipattr.c b/sys/src/ape/lib/bsd/_sock_ipattr.c
new file mode 100755
index 000000000..b9b0c8ac8
--- /dev/null
+++ b/sys/src/ape/lib/bsd/_sock_ipattr.c
@@ -0,0 +1,45 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <ctype.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "priv.h"
+
+/*
+ *  return ndb attribute type of an ip name
+ */
+int
+_sock_ipattr(char *name)
+{
+	char *p;
+	int dot = 0;
+	int alpha = 0;
+
+	for(p = name; *p; p++){
+		if(isdigit(*p))
+			;
+		else if(isalpha(*p) || *p == '-')
+			alpha = 1;
+		else if(*p == '.')
+			dot = 1;
+		else
+			return Tsys;
+	}
+
+	if(alpha){
+		if(dot)
+			return Tdom;
+		else
+			return Tsys;
+	}
+
+	if(dot)
+		return Tip;
+	else
+		return Tsys;
+}
diff --git a/sys/src/ape/lib/bsd/_sock_srv.c b/sys/src/ape/lib/bsd/_sock_srv.c
new file mode 100755
index 000000000..1f2988d03
--- /dev/null
+++ b/sys/src/ape/lib/bsd/_sock_srv.c
@@ -0,0 +1,60 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+
+/* socket extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#include "priv.h"
+
+/* we can't avoid overrunning npath because we don't know how big it is. */
+void
+_sock_srvname(char *npath, char *path)
+{
+	char *p;
+
+	strcpy(npath, "/srv/UD.");
+	p = strrchr(path, '/');
+	if(p == 0)
+		p = path;
+	else
+		p++;
+	strcat(npath, p);
+}
+
+int
+_sock_srv(char *path, int fd)
+{
+	int sfd;
+	char msg[8+256+1];
+
+	/* change the path to something in srv */
+	_sock_srvname(msg, path);
+
+	/* remove any previous instance */
+	unlink(msg);
+
+	/* put the fd in /srv and then close it */
+	sfd = creat(msg, 0666);
+	if(sfd < 0){
+		close(fd);
+		_syserrno();
+		return -1;
+	}
+	snprintf(msg, sizeof msg, "%d", fd);
+	if(write(sfd, msg, strlen(msg)) < 0){
+		_syserrno();
+		close(sfd);
+		close(fd);
+		return -1;
+	}
+	close(sfd);
+	close(fd);
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/accept.c b/sys/src/ape/lib/bsd/accept.c
new file mode 100755
index 000000000..483e4c6ed
--- /dev/null
+++ b/sys/src/ape/lib/bsd/accept.c
@@ -0,0 +1,121 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include "priv.h"
+
+int
+accept(int fd, void *a, int *alen)
+{
+	int n, nfd, cfd;
+	Rock *r, *nr;
+	struct sockaddr_in *ip;
+	char name[Ctlsize];
+	char file[8+Ctlsize+1];
+	char *p, *net;
+
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+
+	switch(r->domain){
+	case PF_INET:
+		switch(r->stype){
+		case SOCK_DGRAM:
+			net = "udp";
+			break;
+		case SOCK_STREAM:
+			net = "tcp";
+			break;
+		}
+
+		/* get control file name from listener process */
+		n = read(fd, name, sizeof(name)-1);
+		if(n <= 0){
+			_syserrno();
+			return -1;
+		}
+		name[n] = 0;
+		cfd = open(name, O_RDWR);
+		if(cfd < 0){
+			_syserrno();
+			return -1;
+		}
+
+		nfd = _sock_data(cfd, net, r->domain, r->stype, r->protocol, &nr);
+		if(nfd < 0){
+			_syserrno();
+			return -1;
+		}
+
+		if(write(fd, "OK", 2) < 0){
+			close(nfd);
+			_syserrno();
+			return -1;
+		}
+
+		/* get remote address */
+		ip = (struct sockaddr_in*)&nr->raddr;
+		_sock_ingetaddr(nr, ip, &n, "remote");
+		if(a){
+			memmove(a, ip, sizeof(struct sockaddr_in));
+			*alen = sizeof(struct sockaddr_in);
+		}
+
+		return nfd;
+	case PF_UNIX:
+		if(r->other >= 0){
+			errno = EGREG;
+			return -1;
+		}
+
+		for(;;){
+			/* read path to new connection */
+			n = read(fd, name, sizeof(name) - 1);
+			if(n < 0)
+				return -1;
+			if(n == 0)
+				continue;
+			name[n] = 0;
+
+			/* open new connection */
+			_sock_srvname(file, name);
+			nfd = open(file, O_RDWR);
+			if(nfd < 0)
+				continue;
+
+			/* confirm opening on new connection */
+			if(write(nfd, name, strlen(name)) > 0)
+				break;
+
+			close(nfd);
+		}
+
+		nr = _sock_newrock(nfd);
+		if(nr == 0){
+			close(nfd);
+			return -1;
+		}
+		nr->domain = r->domain;
+		nr->stype = r->stype;
+		nr->protocol = r->protocol;
+
+		return nfd;
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/sys/src/ape/lib/bsd/bcopy.c b/sys/src/ape/lib/bsd/bcopy.c
new file mode 100755
index 000000000..6e3e02224
--- /dev/null
+++ b/sys/src/ape/lib/bsd/bcopy.c
@@ -0,0 +1,21 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+
+void
+bcopy(void *f, void *t, size_t n)
+{
+	memmove(t, f, n);
+}
+
+int
+bcmp(void *a, void *b, size_t n)
+{
+	return memcmp(a, b, n);
+}
+
+void
+bzero(void *a, size_t n)
+{
+	memset(a, 0, n);
+}
diff --git a/sys/src/ape/lib/bsd/bind.c b/sys/src/ape/lib/bsd/bind.c
new file mode 100755
index 000000000..040c62fa0
--- /dev/null
+++ b/sys/src/ape/lib/bsd/bind.c
@@ -0,0 +1,70 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <signal.h>
+
+/* socket extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+/* plan 9 */
+#include "lib.h"
+#include "sys9.h"
+
+#include "priv.h"
+
+int
+bind(int fd, void *a, int alen)
+{
+	int n, len, cfd;
+	Rock *r;
+	char msg[128];
+	struct sockaddr_in *lip;
+
+	/* assign the address */
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+	if(alen > sizeof(r->addr)){
+		errno = ENAMETOOLONG;
+		return -1;
+	}
+	memmove(&r->addr, a, alen);
+
+	/* the rest is IP sepecific */
+	if (r->domain != PF_INET)
+		return 0;
+
+	cfd = open(r->ctl, O_RDWR);
+	if(cfd < 0){
+		errno = EBADF;
+		return -1;
+	}
+	lip = (struct sockaddr_in*)&r->addr;
+	if(lip->sin_port > 0)
+		snprintf(msg, sizeof msg, "bind %d", ntohs(lip->sin_port));
+	else
+		strcpy(msg, "bind *");
+	n = write(cfd, msg, strlen(msg));
+	if(n < 0){
+		errno = EOPNOTSUPP;	/* Improve error reporting!!! */
+		close(cfd);
+		return -1;
+	}
+	close(cfd);
+
+	if(lip->sin_port <= 0)
+		_sock_ingetaddr(r, lip, &len, "local");
+
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/connect.c b/sys/src/ape/lib/bsd/connect.c
new file mode 100755
index 000000000..3f7dcd6b4
--- /dev/null
+++ b/sys/src/ape/lib/bsd/connect.c
@@ -0,0 +1,111 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include "priv.h"
+
+int
+connect(int fd, void *a, int alen)
+{
+	Rock *r;
+	int n, cfd, nfd;
+	char msg[8+256+1], file[8+256+1];
+	struct sockaddr_in *lip, *rip;
+	struct sockaddr_un *runix;
+	static int vers;
+
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+	if(alen > sizeof(r->raddr)){
+		errno = ENAMETOOLONG;
+		return -1;
+	}
+	memmove(&r->raddr, a, alen);
+
+	switch(r->domain){
+	case PF_INET:
+		/* set up a tcp or udp connection */
+		cfd = open(r->ctl, O_RDWR);
+		if(cfd < 0){
+			_syserrno();
+			return -1;
+		}
+		rip = a;
+		lip = (struct sockaddr_in*)&r->addr;
+		if(lip->sin_port)
+			snprintf(msg, sizeof msg, "connect %s!%d%s %d",
+				inet_ntoa(rip->sin_addr), ntohs(rip->sin_port),
+				r->reserved ? "!r" : "",
+				ntohs(lip->sin_port));
+		else
+			snprintf(msg, sizeof msg, "connect %s!%d%s",
+				inet_ntoa(rip->sin_addr), ntohs(rip->sin_port),
+				r->reserved ? "!r" : "");
+		n = write(cfd, msg, strlen(msg));
+		if(n < 0){
+			_syserrno();
+			close(cfd);
+			return -1;
+		}
+		close(cfd);
+		return 0;
+	case PF_UNIX:
+		/* null terminate the address */
+		if(alen == sizeof(r->raddr))
+			alen--;
+		*(((char*)&r->raddr)+alen) = 0;
+
+		if(r->other < 0){
+			errno = EGREG;
+			return -1;
+		}
+
+		/* put far end of our pipe in /srv */
+		snprintf(msg, sizeof msg, "UD.%d.%d", getpid(), vers++);
+		if(_sock_srv(msg, r->other) < 0){
+			r->other = -1;
+			return -1;
+		}
+		r->other = -1;
+
+		/* tell server the /srv file to open */
+		runix = (struct sockaddr_un*)&r->raddr;
+		_sock_srvname(file, runix->sun_path);
+		nfd = open(file, O_RDWR);
+		if(nfd < 0){
+			_syserrno();
+			unlink(msg);
+			return -1;
+		}
+		if(write(nfd, msg, strlen(msg)) < 0){
+			_syserrno();
+			close(nfd);
+			unlink(msg);
+			return -1;
+		}
+		close(nfd);
+
+		/* wait for server to open it and then remove it */
+		read(fd, file, sizeof(file));
+		_sock_srvname(file, msg);
+		unlink(file);
+		return 0;
+	default:
+		errno = EAFNOSUPPORT;
+		return -1;
+	}
+}
diff --git a/sys/src/ape/lib/bsd/endhostent.c b/sys/src/ape/lib/bsd/endhostent.c
new file mode 100755
index 000000000..aa798b87d
--- /dev/null
+++ b/sys/src/ape/lib/bsd/endhostent.c
@@ -0,0 +1,4 @@
+void
+endhostent(void)
+{
+}
diff --git a/sys/src/ape/lib/bsd/ffs.c b/sys/src/ape/lib/bsd/ffs.c
new file mode 100755
index 000000000..508345365
--- /dev/null
+++ b/sys/src/ape/lib/bsd/ffs.c
@@ -0,0 +1,23 @@
+/* Find the first set bit
+ * i.e. least signifigant 1 bit:
+ * 0 => 0
+ * 1 => 1
+ * 2 => 2
+ * 3 => 1
+ * 4 => 3
+ */
+
+int
+ffs(unsigned int mask)
+{
+	int i;
+
+	if (!mask)
+		return 0;
+	i = 1;
+	while (!(mask & 1)){
+		i++;
+		mask = mask >> 1;
+	}
+	return i;
+}
diff --git a/sys/src/ape/lib/bsd/getdtablesize.c b/sys/src/ape/lib/bsd/getdtablesize.c
new file mode 100755
index 000000000..20e23b17f
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getdtablesize.c
@@ -0,0 +1,8 @@
+/* posix */
+#include <sys/limits.h>
+
+int
+getdtablesize(void)
+{
+	return OPEN_MAX;
+}
diff --git a/sys/src/ape/lib/bsd/gethostbyaddr.c b/sys/src/ape/lib/bsd/gethostbyaddr.c
new file mode 100755
index 000000000..bd58b1dff
--- /dev/null
+++ b/sys/src/ape/lib/bsd/gethostbyaddr.c
@@ -0,0 +1,29 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+int h_errno;
+
+struct hostent*
+gethostbyaddr(void *addr, int len, int type)
+{
+	unsigned long a, y;
+	struct in_addr x;
+	unsigned char *p = addr;
+
+	if(type != AF_INET || len != 4){
+		h_errno = NO_RECOVERY;
+		return 0;
+	}
+
+	y = (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3];
+	x.s_addr = htonl(y);
+
+	return gethostbyname(inet_ntoa(x));
+}
diff --git a/sys/src/ape/lib/bsd/gethostbyname.c b/sys/src/ape/lib/bsd/gethostbyname.c
new file mode 100755
index 000000000..749798510
--- /dev/null
+++ b/sys/src/ape/lib/bsd/gethostbyname.c
@@ -0,0 +1,131 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+#include "priv.h"
+
+int h_errno;
+
+enum
+{
+	Nname= 6,
+};
+
+/*
+ *  for inet addresses only
+ */
+struct hostent*
+gethostbyname(char *name)
+{
+	int i, t, fd, m;
+	char *p, *bp;
+	int nn, na;
+	unsigned long x;
+	static struct hostent h;
+	static char buf[1024];
+	static char *nptr[Nname+1];
+	static char *aptr[Nname+1];
+	static char addr[Nname][4];
+
+	h.h_name = 0;
+	t = _sock_ipattr(name);
+
+	/* connect to server */
+	fd = open("/net/cs", O_RDWR);
+	if(fd < 0){
+		_syserrno();
+		h_errno = NO_RECOVERY;
+		return 0;
+	}
+
+	/* construct the query, always expect an ip# back */
+	switch(t){
+	case Tsys:
+		snprintf(buf, sizeof buf, "!sys=%s ip=*", name);
+		break;
+	case Tdom:
+		snprintf(buf, sizeof buf, "!dom=%s ip=*", name);
+		break;
+	case Tip:
+		snprintf(buf, sizeof buf, "!ip=%s", name);
+		break;
+	}
+
+	/* query the server */
+	if(write(fd, buf, strlen(buf)) < 0){
+		_syserrno();
+		h_errno = TRY_AGAIN;
+		return 0;
+	}
+	lseek(fd, 0, 0);
+	for(i = 0; i < sizeof(buf)-1; i += m){
+		m = read(fd, buf+i, sizeof(buf) - 1 - i);
+		if(m <= 0)
+			break;
+		buf[i+m++] = ' ';
+	}
+	close(fd);
+	buf[i] = 0;
+
+	/* parse the reply */
+	nn = na = 0;
+	for(bp = buf;;){
+		p = strchr(bp, '=');
+		if(p == 0)
+			break;
+		*p++ = 0;
+		if(strcmp(bp, "dom") == 0){
+			if(h.h_name == 0)
+				h.h_name = p;
+			if(nn < Nname)
+				nptr[nn++] = p;
+		} else if(strcmp(bp, "sys") == 0){
+			if(nn < Nname)
+				nptr[nn++] = p;
+		} else if(strcmp(bp, "ip") == 0){
+			x = inet_addr(p);
+			x = ntohl(x);
+			if(na < Nname){
+				addr[na][0] = x>>24;
+				addr[na][1] = x>>16;
+				addr[na][2] = x>>8;
+				addr[na][3] = x;
+				aptr[na] = addr[na];
+				na++;
+			}
+		}
+		while(*p && *p != ' ')
+			p++;
+		if(*p)
+			*p++ = 0;
+		bp = p;
+	}
+	if(nn+na == 0){
+		h_errno = HOST_NOT_FOUND;
+		return 0;
+	}
+
+	nptr[nn] = 0;
+	aptr[na] = 0;
+	h.h_aliases = nptr;
+	h.h_addr_list = aptr;
+	h.h_length = 4;
+	h.h_addrtype = AF_INET;
+	if(h.h_name == 0)
+		h.h_name = nptr[0];
+	if(h.h_name == 0)
+		h.h_name = aptr[0];
+
+	return &h;
+}
diff --git a/sys/src/ape/lib/bsd/gethostname.c b/sys/src/ape/lib/bsd/gethostname.c
new file mode 100755
index 000000000..5ecdd94b8
--- /dev/null
+++ b/sys/src/ape/lib/bsd/gethostname.c
@@ -0,0 +1,25 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+
+int
+gethostname(char *name, int namelen)
+{
+	int n, fd;
+	char buf[128];
+
+	fd = open("/dev/sysname", O_RDONLY);
+	if(fd < 0)
+		return -1;
+	n = read(fd, buf, sizeof(buf)-1);
+	close(fd);
+	if(n <= 0)
+		return -1;
+	buf[n] = 0;
+	strncpy(name, buf, namelen);
+	name[namelen-1] = 0;
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/getopt.c b/sys/src/ape/lib/bsd/getopt.c
new file mode 100755
index 000000000..0116b1183
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getopt.c
@@ -0,0 +1,52 @@
+#include	<stdlib.h>
+#include	<string.h>
+#include	<stdio.h>
+#define ERR(str, chr)       if(opterr){fprintf(stderr, "%s%s%c\n", argv[0], str, chr);}
+int     opterr = 1;
+int     optind = 1;
+int	optopt;
+char    *optarg;
+
+int
+getopt (int argc, char **argv, char *opts)
+{
+	static int sp = 1;
+	register c;
+	register char *cp;
+
+	if (sp == 1)
+		if (optind >= argc ||
+		   argv[optind][0] != '-' || argv[optind][1] == '\0')
+			return EOF;
+		else if (strcmp(argv[optind], "--") == 0) {
+			optind++;
+			return EOF;
+		}
+	optopt = c = argv[optind][sp];
+	if (c == ':' || (cp=strchr(opts, c)) == NULL) {
+		ERR (": illegal option -- ", c);
+		if (argv[optind][++sp] == '\0') {
+			optind++;
+			sp = 1;
+		}
+		return '?';
+	}
+	if (*++cp == ':') {
+		if (argv[optind][sp+1] != '\0')
+			optarg = &argv[optind++][sp+1];
+		else if (++optind >= argc) {
+			ERR (": option requires an argument -- ", c);
+			sp = 1;
+			return '?';
+		} else
+			optarg = argv[optind++];
+		sp = 1;
+	} else {
+		if (argv[optind][++sp] == '\0') {
+			sp = 1;
+			optind++;
+		}
+		optarg = NULL;
+	}
+	return c;
+}
diff --git a/sys/src/ape/lib/bsd/getpeername.c b/sys/src/ape/lib/bsd/getpeername.c
new file mode 100755
index 000000000..e4dd3109c
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getpeername.c
@@ -0,0 +1,49 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include "priv.h"
+
+int
+getpeername(int fd, struct sockaddr *addr, int *alen)
+{
+	Rock *r;
+	int i;
+	struct sockaddr_in *rip;
+	struct sockaddr_un *runix;
+
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+
+	switch(r->domain){
+	case PF_INET:
+		rip = (struct sockaddr_in*)&r->raddr;
+		memmove(addr, rip, sizeof(struct sockaddr_in));
+		*alen = sizeof(struct sockaddr_in);
+		break;
+	case PF_UNIX:
+		runix = (struct sockaddr_un*)&r->raddr;
+		i = &runix->sun_path[strlen(runix->sun_path)] - (char*)runix;
+		memmove(addr, runix, i);
+		*alen = i;
+		break;
+	default:
+		errno = EAFNOSUPPORT;
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/getprotobyname.c b/sys/src/ape/lib/bsd/getprotobyname.c
new file mode 100755
index 000000000..f88d70148
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getprotobyname.c
@@ -0,0 +1,90 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+#include "priv.h"
+
+extern int h_errno;
+
+enum
+{
+	Nname= 6,
+};
+
+static struct protoent r;
+
+struct protoent *getprotobyname(const char *name) {
+	int fd, i, m;
+	char *p, *bp;
+	int nn, na;
+	unsigned long x;
+	static char buf[1024], proto[1024];
+	static char *nptr[Nname+1];
+
+	/* connect to server */
+	fd = open("/net/cs", O_RDWR);
+	if(fd < 0){
+		_syserrno();
+		h_errno = NO_RECOVERY;
+		return 0;
+	}
+
+	/* construct the query, always expect a protocol# back */
+	snprintf(buf, sizeof buf, "!protocol=%s ipv4proto=*", name);
+
+	/* query the server */
+	if(write(fd, buf, strlen(buf)) < 0){
+		_syserrno();
+		h_errno = TRY_AGAIN;
+		return 0;
+	}
+	lseek(fd, 0, 0);
+	for(i = 0; i < sizeof(buf)-1; i += m){
+		m = read(fd, buf+i, sizeof(buf) - 1 - i);
+		if(m <= 0)
+			break;
+		buf[i+m++] = ' ';
+	}
+	close(fd);
+	buf[i] = 0;
+
+	/* parse the reply */
+	nn = na = 0;
+	for(bp = buf;;){
+		p = strchr(bp, '=');
+		if(p == 0)
+			break;
+		*p++ = 0;
+		if(strcmp(bp, "protocol") == 0){
+			if(!nn)
+				r.p_name = p;
+			if(nn < Nname)
+				nptr[nn++] = p;
+		} else if(strcmp(bp, "ipv4proto") == 0){
+			r.p_proto = atoi(p);
+			na++;
+		}
+		while(*p && *p != ' ')
+			p++;
+		if(*p)
+			*p++ = 0;
+		bp = p;
+	}
+	nptr[nn] = 0;
+	r.p_aliases = nptr;
+	if (nn+na == 0)
+		return 0;
+
+	return &r;
+}
diff --git a/sys/src/ape/lib/bsd/getservbyaddr.c b/sys/src/ape/lib/bsd/getservbyaddr.c
new file mode 100755
index 000000000..cafb72d04
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getservbyaddr.c
@@ -0,0 +1,18 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+struct servent*
+getservbyport(int port, char *proto)
+{
+	char buf[32];
+
+	snprintf(buf, sizeof buf, "%d", port);
+	return getservbyname(buf, proto);
+}
diff --git a/sys/src/ape/lib/bsd/getservbyname.c b/sys/src/ape/lib/bsd/getservbyname.c
new file mode 100755
index 000000000..0212d5403
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getservbyname.c
@@ -0,0 +1,100 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+#include "priv.h"
+
+enum
+{
+	Nname= 6,
+};
+
+/*
+ *  for inet addresses only
+ */
+struct servent*
+getservbyname(char *name, char *proto)
+{
+	int i, fd, m, num;
+	char *p, *bp;
+	int nn, na;
+	static struct servent s;
+	static char buf[1024];
+	static char *nptr[Nname+1];
+
+	num = 1;
+	for(p = name; *p; p++)
+		if(!isdigit(*p))
+			num = 0;
+
+	s.s_name = 0;
+
+	/* connect to server */
+	fd = open("/net/cs", O_RDWR);
+	if(fd < 0){
+		_syserrno();
+		return 0;
+	}
+
+	/* construct the query, always expect an ip# back */
+	if(num)
+		snprintf(buf, sizeof buf, "!port=%s %s=*", name, proto);
+	else
+		snprintf(buf, sizeof buf, "!%s=%s port=*", proto, name);
+
+	/* query the server */
+	if(write(fd, buf, strlen(buf)) < 0){
+		_syserrno();
+		return 0;
+	}
+	lseek(fd, 0, 0);
+	for(i = 0; i < sizeof(buf)-1; i += m){
+		m = read(fd, buf+i, sizeof(buf) - 1 - i);
+		if(m <= 0)
+			break;
+		buf[i+m++] = ' ';
+	}
+	close(fd);
+	buf[i] = 0;
+
+	/* parse the reply */
+	nn = na = 0;
+	for(bp = buf;;){
+		p = strchr(bp, '=');
+		if(p == 0)
+			break;
+		*p++ = 0;
+		if(strcmp(bp, proto) == 0){
+			if(nn < Nname)
+				nptr[nn++] = p;
+		} else if(strcmp(bp, "port") == 0){
+			s.s_port = htons(atoi(p));
+		}
+		while(*p && *p != ' ')
+			p++;
+		if(*p)
+			*p++ = 0;
+		bp = p;
+	}
+	if(nn+na == 0)
+		return 0;
+
+	nptr[nn] = 0;
+	s.s_aliases = nptr;
+	if(s.s_name == 0)
+		s.s_name = nptr[0];
+
+	return &s;
+}
diff --git a/sys/src/ape/lib/bsd/getsockname.c b/sys/src/ape/lib/bsd/getsockname.c
new file mode 100755
index 000000000..aa22d3217
--- /dev/null
+++ b/sys/src/ape/lib/bsd/getsockname.c
@@ -0,0 +1,48 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include "priv.h"
+
+int
+getsockname(int fd, struct sockaddr *addr, int *alen)
+{
+	Rock *r;
+	int i;
+	struct sockaddr_in *lip;
+	struct sockaddr_un *lunix;
+
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+
+	switch(r->domain){
+	case PF_INET:
+		lip = (struct sockaddr_in*)addr;
+		_sock_ingetaddr(r, lip, alen, "local");
+		break;
+	case PF_UNIX:
+		lunix = (struct sockaddr_un*)&r->addr;
+		i = &lunix->sun_path[strlen(lunix->sun_path)] - (char*)lunix;
+		memmove(addr, lunix, i);
+		*alen = i;
+		break;
+	default:
+		errno = EAFNOSUPPORT;
+		return -1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/gettimeofday.c b/sys/src/ape/lib/bsd/gettimeofday.c
new file mode 100755
index 000000000..ee347f36a
--- /dev/null
+++ b/sys/src/ape/lib/bsd/gettimeofday.c
@@ -0,0 +1,56 @@
+#include <sys/types.h>
+#include <time.h>
+#include <sys/time.h>
+#include <string.h>
+#include "sys9.h"
+
+typedef unsigned long long uvlong;
+typedef long long vlong;
+typedef unsigned char uchar;
+
+static uvlong order = 0x0001020304050607ULL;
+
+static void
+be2vlong(vlong *to, uchar *f)
+{
+	uchar *t, *o;
+	int i;
+
+	t = (uchar*)to;
+	o = (uchar*)&order;
+	for(i = 0; i < 8; i++)
+		t[o[i]] = f[i];
+}
+
+int
+gettimeofday(struct timeval *tp, struct timezone *tzp)
+{
+	uchar b[8];
+	vlong t;
+	int opened;
+	static int fd = -1;
+
+	opened = 0;
+	for(;;) {
+		if(fd < 0)
+			if(opened++ ||
+			    (fd = _OPEN("/dev/bintime", OREAD|OCEXEC)) < 0)
+				return 0;
+		if(_PREAD(fd, b, sizeof b, 0) == sizeof b)
+			break;		/* leave fd open for future use */
+		/* short read, perhaps try again */
+		_CLOSE(fd);
+		fd = -1;
+	}
+	be2vlong(&t, b);
+
+	tp->tv_sec = t/1000000000;
+	tp->tv_usec = (t/1000)%1000000;
+
+	if(tzp) {
+		tzp->tz_minuteswest = 4*60;	/* BUG */
+		tzp->tz_dsttime = 1;
+	}
+
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/inet_addr.c b/sys/src/ape/lib/bsd/inet_addr.c
new file mode 100755
index 000000000..63cd69cc4
--- /dev/null
+++ b/sys/src/ape/lib/bsd/inet_addr.c
@@ -0,0 +1,52 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#define CLASS(x)	(x[0]>>6)
+
+unsigned long
+inet_addr(char *from)
+{
+	int i;
+	char *p;
+	unsigned char to[4];
+	unsigned long x;
+ 
+	p = from;
+	memset(to, 0, 4);
+	for(i = 0; i < 4 && *p; i++){
+		to[i] = strtoul(p, &p, 0);
+		if(*p == '.')
+			p++;
+	}
+
+	switch(CLASS(to)){
+	case 0:	/* class A - 1 byte net */
+	case 1:
+		if(i == 3){
+			to[3] = to[2];
+			to[2] = to[1];
+			to[1] = 0;
+		} else if (i == 2){
+			to[3] = to[1];
+			to[1] = 0;
+		}
+		break;
+	case 2:	/* class B - 2 byte net */
+		if(i == 3){
+			to[3] = to[2];
+			to[2] = 0;
+		}
+		break;
+	}
+	x = nptohl(to);
+	x = htonl(x);
+	return x;
+}
diff --git a/sys/src/ape/lib/bsd/inet_ntoa.c b/sys/src/ape/lib/bsd/inet_ntoa.c
new file mode 100755
index 000000000..03dd714dd
--- /dev/null
+++ b/sys/src/ape/lib/bsd/inet_ntoa.c
@@ -0,0 +1,22 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+char*
+inet_ntoa(struct in_addr in)
+{
+	static char s[18];
+	unsigned char *p;	
+
+	p = (unsigned char*)&in.s_addr;
+	snprintf(s, sizeof s, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
+	return s;
+}
diff --git a/sys/src/ape/lib/bsd/ioctl.c b/sys/src/ape/lib/bsd/ioctl.c
new file mode 100755
index 000000000..0155de573
--- /dev/null
+++ b/sys/src/ape/lib/bsd/ioctl.c
@@ -0,0 +1,33 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+int
+ioctl(int fd, unsigned long request, void* arg)
+{
+	struct stat d;
+
+	if(request == FIONREAD) {
+		if(fstat(fd, &d) < 0) {
+			errno = EBADF;
+			return -1;
+		}
+		/* this works if the file is buffered somehow */
+		*(long*)arg = d.st_size;
+		return 0;
+	} else {
+		errno = EINVAL;
+		return -1;
+	}
+}
diff --git a/sys/src/ape/lib/bsd/listen.c b/sys/src/ape/lib/bsd/listen.c
new file mode 100755
index 000000000..655e2a06f
--- /dev/null
+++ b/sys/src/ape/lib/bsd/listen.c
@@ -0,0 +1,176 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <signal.h>
+
+/* socket extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+/* plan 9 */
+#include "lib.h"
+#include "sys9.h"
+
+#include "priv.h"
+
+extern int	_muxsid;
+extern void	_killmuxsid(void);
+
+/*
+ * replace the fd with a pipe and start a process to
+ * accept calls in.  this is all to make select work.
+ */
+static int
+listenproc(Rock *r, int fd)
+{
+	Rock *nr;
+	char *net;
+	int cfd, nfd, dfd;
+	int pfd[2];
+	struct stat d;
+	char *p;
+	char listen[Ctlsize];
+	char name[Ctlsize];
+
+	switch(r->stype){
+	case SOCK_DGRAM:
+		net = "udp";
+		break;
+	case SOCK_STREAM:
+		net = "tcp";
+		break;
+	}
+
+	strcpy(listen, r->ctl);
+	p = strrchr(listen, '/');
+	if(p == 0)
+		return -1;
+	strcpy(p+1, "listen");
+
+	if(pipe(pfd) < 0)
+		return -1;
+
+	/* replace fd with a pipe */
+	nfd = dup(fd);
+	dup2(pfd[0], fd);
+	close(pfd[0]);
+	fstat(fd, &d);
+	r->inode = d.st_ino;
+	r->dev = d.st_dev;
+
+	/* start listening process */
+	switch(fork()){
+	case -1:
+		close(pfd[1]);
+		close(nfd);
+		return -1;
+	case 0:
+		if(_muxsid == -1) {
+			_RFORK(RFNOTEG);
+			_muxsid = getpgrp();
+		} else
+			setpgid(getpid(), _muxsid);
+		_RENDEZVOUS(2, _muxsid);
+		break;
+	default:
+		atexit(_killmuxsid);
+		_muxsid = _RENDEZVOUS(2, 0);
+		close(pfd[1]);
+		close(nfd);
+		return 0;
+	}
+
+/*	for(fd = 0; fd < 30; fd++)
+		if(fd != nfd && fd != pfd[1])
+			close(fd);/**/
+
+	for(;;){
+		cfd = open(listen, O_RDWR);
+		if(cfd < 0)
+			break;
+
+		dfd = _sock_data(cfd, net, r->domain, r->stype, r->protocol, &nr);
+		if(dfd < 0)
+			break;
+
+		if(write(pfd[1], nr->ctl, strlen(nr->ctl)) < 0)
+			break;
+		if(read(pfd[1], name, sizeof(name)) <= 0)
+			break;
+
+		close(dfd);
+	}
+	exit(0);
+}
+
+int
+listen(fd, backlog)
+	int fd;
+	int backlog;
+{
+	Rock *r;
+	int n, cfd;
+	char msg[128];
+	struct sockaddr_in *lip;
+	struct sockaddr_un *lunix;
+
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+
+	switch(r->domain){
+	case PF_INET:
+		cfd = open(r->ctl, O_RDWR);
+		if(cfd < 0){
+			errno = EBADF;
+			return -1;
+		}
+		lip = (struct sockaddr_in*)&r->addr;
+		if(lip->sin_port >= 0) {
+			if(write(cfd, "bind 0", 6) < 0) {
+				errno = EGREG;
+				close(cfd);
+				return -1;
+			}
+			snprintf(msg, sizeof msg, "announce %d",
+				ntohs(lip->sin_port));
+		}
+		else
+			strcpy(msg, "announce *");
+		n = write(cfd, msg, strlen(msg));
+		if(n < 0){
+			errno = EOPNOTSUPP;	/* Improve error reporting!!! */
+			close(cfd);
+			return -1;
+		}
+		close(cfd);
+
+		return listenproc(r, fd);
+	case PF_UNIX:
+		if(r->other < 0){
+			errno = EGREG;
+			return -1;
+		}
+		lunix = (struct sockaddr_un*)&r->addr;
+		if(_sock_srv(lunix->sun_path, r->other) < 0){
+			_syserrno();
+			r->other = -1;
+			return -1;
+		}
+		r->other = -1;
+		return 0;
+	default:
+		errno = EAFNOSUPPORT;
+		return -1;
+	}
+}
diff --git a/sys/src/ape/lib/bsd/lstat.c b/sys/src/ape/lib/bsd/lstat.c
new file mode 100755
index 000000000..d929e7ef1
--- /dev/null
+++ b/sys/src/ape/lib/bsd/lstat.c
@@ -0,0 +1,23 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+int
+lstat(char *name, struct stat *ans)
+{
+	return stat(name, ans);
+}
+
+int
+symlink(char *name1, char *name2)
+{
+	errno = EPERM;
+	return -1;
+}
+
+int
+readlink(char *name, char *buf, int size)
+{
+	errno = EIO;
+	return -1;
+}
diff --git a/sys/src/ape/lib/bsd/mkfile b/sys/src/ape/lib/bsd/mkfile
new file mode 100755
index 000000000..44b4b05fb
--- /dev/null
+++ b/sys/src/ape/lib/bsd/mkfile
@@ -0,0 +1,55 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libbsd.a
+OFILES=\
+	accept.$O\
+	bcopy.$O\
+	bind.$O\
+	connect.$O\
+	endhostent.$O\
+	ffs.$O\
+	getdtablesize.$O\
+	gethostbyname.$O\
+	gethostbyaddr.$O\
+	gethostname.$O\
+	getopt.$O\
+	getpeername.$O\
+	getprotobyname.$O\
+	getservbyaddr.$O\
+	getservbyname.$O\
+	getsockname.$O\
+	gettimeofday.$O\
+	inet_addr.$O\
+	inet_ntoa.$O\
+	ioctl.$O\
+	listen.$O\
+	lstat.$O\
+	mktemp.$O\
+	ntohl.$O\
+	nptohl.$O\
+	popen.$O\
+	putenv.$O\
+	rcmd.$O\
+	readv.$O\
+	rresvport.$O\
+	send.$O\
+	sendto.$O\
+	setlinebuf.$O\
+	shutdown.$O\
+	_sock_ingetaddr.$O\
+	_sock_ipattr.$O\
+	_sock_srv.$O\
+	strcasecmp.$O\
+	strncasecmp.$O\
+	socket.$O\
+	socketpair.$O\
+	strdup.$O\
+	pty.$O\
+	writev.$O\
+	
+HFILES=priv.h
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_BSD_EXTENSION -D_PLAN9_SOURCE -I../ap/plan9
diff --git a/sys/src/ape/lib/bsd/mktemp.c b/sys/src/ape/lib/bsd/mktemp.c
new file mode 100755
index 000000000..d48714a32
--- /dev/null
+++ b/sys/src/ape/lib/bsd/mktemp.c
@@ -0,0 +1,33 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+
+char*
+mktemp(char *template)
+{
+	int n;
+	long x;
+	char *p;
+	int c;
+	struct stat stbuf;
+
+	n = strlen(template);
+	p = template+n-6;
+	if (n < 6 || strcmp(p, "XXXXXX") != 0) {
+		*template = 0;
+	} else {
+		x = getpid() % 100000;
+		sprintf(p, "%05d", x);
+		p += 5;
+		for(c = 'a'; c <= 'z'; c++) {
+			*p = c;
+			if (stat(template, &stbuf) < 0)
+				return template;
+		}
+		*template = 0;
+	}
+	return template;
+}
diff --git a/sys/src/ape/lib/bsd/nptohl.c b/sys/src/ape/lib/bsd/nptohl.c
new file mode 100755
index 000000000..c012493e9
--- /dev/null
+++ b/sys/src/ape/lib/bsd/nptohl.c
@@ -0,0 +1,10 @@
+unsigned long
+nptohl(void *p)
+{
+	unsigned char *up;
+	unsigned long x;
+
+	up = p;
+	x = (up[0]<<24)|(up[1]<<16)|(up[2]<<8)|up[3];
+	return x;
+}
diff --git a/sys/src/ape/lib/bsd/ntohl.c b/sys/src/ape/lib/bsd/ntohl.c
new file mode 100755
index 000000000..29c19d6fb
--- /dev/null
+++ b/sys/src/ape/lib/bsd/ntohl.c
@@ -0,0 +1,47 @@
+unsigned long
+ntohl(int x)
+{
+	unsigned long n;
+	unsigned char *p;
+
+	n = x;
+	p = (unsigned char*)&n;
+	return (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3];
+}
+
+unsigned long
+htonl(unsigned long h)
+{
+	unsigned long n;
+	unsigned char *p;
+
+	p = (unsigned char*)&n;
+	p[0] = h>>24;
+	p[1] = h>>16;
+	p[2] = h>>8;
+	p[3] = h;
+	return n;
+}
+
+unsigned short
+ntohs(int x)
+{
+	unsigned short n;
+	unsigned char *p;
+
+	n = x;
+	p = (unsigned char*)&n;
+	return (p[0]<<8)|p[1];
+}
+
+unsigned short
+htons(unsigned short h)
+{
+	unsigned short n;
+	unsigned char *p;
+
+	p = (unsigned char*)&n;
+	p[0] = h>>8;
+	p[1] = h;
+	return n;
+}
diff --git a/sys/src/ape/lib/bsd/popen.c b/sys/src/ape/lib/bsd/popen.c
new file mode 100755
index 000000000..32af1de3d
--- /dev/null
+++ b/sys/src/ape/lib/bsd/popen.c
@@ -0,0 +1,84 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#define MAXFORKS	20
+#define NSYSFILE	3
+#define	tst(a,b)	(*mode == 'r'? (b) : (a))
+#define	RDR	0
+#define	WTR	1
+
+struct a_fork {
+	short	done;
+	short	fd;
+	int	pid;
+	int	status;
+};
+static struct a_fork the_fork[MAXFORKS];
+
+FILE *
+popen(char *cmd, char *mode)
+{
+	int p[2];
+	int myside, hisside, pid;
+	int i, ind;
+
+	for (ind = 0; ind < MAXFORKS; ind++)
+		if (the_fork[ind].pid == 0)
+			break;
+	if (ind == MAXFORKS)
+		return NULL;
+	if(pipe(p) < 0)
+		return NULL;
+	myside = tst(p[WTR], p[RDR]);
+	hisside = tst(p[RDR], p[WTR]);
+	switch (pid = fork()) {
+	case -1:
+		return NULL;
+	case 0:
+		/* myside and hisside reverse roles in child */
+		close(myside);
+		dup2(hisside, tst(0, 1));
+		for (i=NSYSFILE; i<FOPEN_MAX; i++)
+			close(i);
+		execl("/bin/ape/sh", "sh", "-c", cmd, NULL);
+		_exit(1);
+	default:
+		the_fork[ind].pid = pid;
+		the_fork[ind].fd = myside;
+		the_fork[ind].done = 0;
+		close(hisside);
+		return(fdopen(myside, mode));
+	}
+}
+
+int
+pclose(FILE *ptr)
+{
+	int f, r, ind;
+	int status;
+
+	f = fileno(ptr);
+	fclose(ptr);
+	for (ind = 0; ind < MAXFORKS; ind++)
+		if (the_fork[ind].fd == f && the_fork[ind].pid != 0)
+			break;
+	if (ind == MAXFORKS)
+		return 0;
+	if (!the_fork[ind].done) {
+		do {
+			r = wait(&status);
+			for (f = 0; f < MAXFORKS; f++)
+				if (the_fork[f].pid == r) {
+					the_fork[f].done = 1;
+					the_fork[f].status = status;
+					break;
+				}
+		} while(r != the_fork[ind].pid && r != -1);
+		the_fork[ind].status = r == -1 ? -1 : status;
+	}
+	the_fork[ind].pid = 0;
+	return (the_fork[ind].status);
+}
diff --git a/sys/src/ape/lib/bsd/priv.h b/sys/src/ape/lib/bsd/priv.h
new file mode 100755
index 000000000..f99fc5673
--- /dev/null
+++ b/sys/src/ape/lib/bsd/priv.h
@@ -0,0 +1,46 @@
+typedef struct Rock Rock;
+
+enum
+{
+	Ctlsize=	128,
+
+	/* states */
+	Sopen=	0,
+	Sbound,
+	Sconnected,
+
+	/* types of name */
+	Tsys=	0,
+	Tip,
+	Tdom,
+};
+
+/*
+ *  since BSD programs expect to perform both control and data functions
+ *  through a single fd, we need to hide enough info under a rock to
+ *  be able to open the control file when we need it.
+ */
+struct Rock
+{
+	Rock		*next;
+	unsigned long	dev;		/* inode & dev of data file */
+	unsigned long	inode;		/* ... */
+	int		domain;		/* from socket call */
+	int		stype;		/* ... */
+	int		protocol;	/* ... */
+	struct sockaddr	addr;		/* address from bind */
+	int		reserved;	/* use a priveledged port # (< 1024) */
+	struct sockaddr	raddr;		/* peer address */
+	char		ctl[Ctlsize];	/* name of control file (if any) */
+	int		other;		/* fd of the remote end for Unix domain */
+};
+
+extern Rock*	_sock_findrock(int, struct stat*);
+extern Rock*	_sock_newrock(int);
+extern void	_sock_srvname(char*, char*);
+extern int	_sock_srv(char*, int);
+extern int	_sock_data(int, char*, int, int, int, Rock**);
+extern int	_sock_ipattr(char*);
+extern void	_sock_ingetaddr(Rock*, struct sockaddr_in*, int*, char*);
+
+extern void	_syserrno(void);
diff --git a/sys/src/ape/lib/bsd/pty.c b/sys/src/ape/lib/bsd/pty.c
new file mode 100755
index 000000000..3189d24e1
--- /dev/null
+++ b/sys/src/ape/lib/bsd/pty.c
@@ -0,0 +1,111 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include <sys/pty.h>
+#include "lib.h"
+#include "sys9.h"
+#include "dir.h"
+
+/*
+ * return the name of the slave
+ */
+char*
+ptsname(int fd)
+{
+	Dir *d;
+	static char buf[32];
+
+	if((d = _dirfstat(fd)) == nil || strlen(d->name) < 4){
+		free(d);
+		_syserrno();
+		return 0;
+	}
+	snprintf(buf, sizeof buf, "/dev/ptty%d", atoi(d->name+4));
+	free(d);
+	return buf;
+}
+
+/*
+ * return the name of the master
+ */
+char*
+ptmname(int fd)
+{
+	Dir *d;
+	static char buf[32];
+
+	if((d = _dirfstat(fd)) == nil || strlen(d->name) < 4){
+		free(d);
+		_syserrno();
+		return 0;
+	}
+
+	snprintf(buf, sizeof buf, "/dev/ttym%d", atoi(d->name+4));
+	return buf;
+}
+
+static char ptycl[] = "/dev/ptyclone";
+static char fssrv[] = "/srv/ptyfs";
+
+static void
+mkserver(void)
+{
+	int fd, i;
+	char *argv[3];
+
+	fd = _OPEN(fssrv, O_RDWR);
+	if(_MOUNT(fd, -1, "/dev", MAFTER, "") < 0) {
+		/*
+		 * remove fssrv here, if it exists, to avoid a race
+		 * between the loop in the default case below and the
+		 * new ptyfs removing fssrv when it starts.
+		 * we otherwise might be unlucky enough to open the old
+		 * (hung channel) fssrv before ptyfs removes it and break
+		 * out of the loop with an open fd to a hung channel?
+		 */
+		_CLOSE(fd);
+		_REMOVE(fssrv);
+		switch(_RFORK(RFPROC|RFFDG)) {
+		case -1:
+			return;
+		case 0:
+			argv[0] = "ptyfs";
+			argv[1] = 0;
+			_EXEC("/bin/ape/ptyfs", argv);
+			_EXITS(0);
+		default:
+			for(i = 0; i < 3; i++) {
+				fd = _OPEN(fssrv, O_RDWR);
+				if(fd >= 0)
+					break;
+				_SLEEP(1000);
+			}
+		}
+		if(fd < 0)
+			return;
+		if(_MOUNT(fd, -1, "/dev", MAFTER, "") < 0)
+			_CLOSE(fd);
+	}
+	/* successful _MOUNT closes fd */
+}
+
+/*
+ * allocate a new pty
+ */
+int
+_getpty(void)
+{
+	struct stat sb;
+
+	if(stat(ptycl, &sb) < 0)
+		mkserver();
+
+	return open(ptycl, O_RDWR);
+}
diff --git a/sys/src/ape/lib/bsd/putenv.c b/sys/src/ape/lib/bsd/putenv.c
new file mode 100755
index 000000000..63695ba76
--- /dev/null
+++ b/sys/src/ape/lib/bsd/putenv.c
@@ -0,0 +1,32 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+int
+putenv(char *s)
+{
+	int f, n;
+	char *value;
+	char buf[300];
+
+	value = strchr(s, '=');
+	if (value) {
+		n = value-s;
+		if(n<=0 || n > sizeof(buf)-6)
+			return -1;
+		strcpy(buf, "/env/");
+		strncpy(buf+5, s, n);
+		buf[n+5] = 0;
+		f = creat(buf, 0666);
+		if(f < 0)
+			return 1;
+		value++;
+		n = strlen(value);
+		if(write(f, value, n) != n)
+			return -1;
+		close(f);
+		return 0;
+	} else
+		return -1;
+}
diff --git a/sys/src/ape/lib/bsd/rcmd.c b/sys/src/ape/lib/bsd/rcmd.c
new file mode 100755
index 000000000..bac11735f
--- /dev/null
+++ b/sys/src/ape/lib/bsd/rcmd.c
@@ -0,0 +1,138 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+
+/* socket extensions */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <netdb.h>
+
+#include "priv.h"
+
+static char pbotch[] = "rcmd: protocol botch\n";
+static char lbotch[] = "rcmd: botch starting error stream\n";
+
+static void
+ding(int x)
+{
+}
+
+int
+rcmd(char **dst, int port, char *luser, char *ruser, char *cmd, int *fd2p)
+{
+	char c;
+	int i, fd, lfd, fd2, port2;
+	struct hostent *h;
+	Rock *r;
+	struct sockaddr_in in;
+	char buf[128];
+	void	(*x)(int);
+
+	h = gethostbyname(*dst);
+	if(h == 0)
+		return -1;
+	*dst = h->h_name;
+
+	/* connect using a reserved tcp port */
+	fd = socket(PF_INET, SOCK_STREAM, 0);
+	if(fd < 0)
+		return -1;
+	r = _sock_findrock(fd, 0);
+	if(r == 0){
+		errno = ENOTSOCK;
+		return -1;
+	}
+	r->reserved = 1;
+	in.sin_family = AF_INET;
+	in.sin_port = htons(port);
+	memmove(&in.sin_addr, h->h_addr_list[0], sizeof(in.sin_addr));
+	if(connect(fd, &in, sizeof(in)) < 0){
+		close(fd);
+		return -1;
+	}
+
+	/* error stream */
+	if(fd2p){
+		/* create an error stream and wait for a call in */
+		for(i = 0; i < 10; i++){
+			lfd = rresvport(&port2);
+			if(lfd < 0)
+				continue;
+			if(listen(lfd, 1) == 0)
+				break;
+			close(lfd);
+		}
+		if(i >= 10){
+			fprintf(stderr, pbotch);
+			return -1;
+		}
+
+		snprintf(buf, sizeof buf, "%d", port2);
+		if(write(fd, buf, strlen(buf)+1) < 0){
+			close(fd);
+			close(lfd);
+			fprintf(stderr, lbotch);
+			return -1;
+		}
+	} else {
+		if(write(fd, "", 1) < 0){
+			fprintf(stderr, pbotch);
+			return -1;
+		}
+	}
+
+	/* pass id's and command */
+	if(write(fd, luser, strlen(luser)+1) < 0
+	|| write(fd, ruser, strlen(ruser)+1) < 0
+	|| write(fd, cmd, strlen(cmd)+1) < 0){
+		if(fd2p)
+			close(fd2);
+		fprintf(stderr, pbotch);
+		return -1;
+	}
+
+	if(fd2p){
+		x = signal(SIGALRM, ding);
+		alarm(15);
+		fd2 = accept(lfd, &in, &i);
+		alarm(0);
+		close(lfd);
+		signal(SIGALRM, x);
+
+		if(fd2 < 0){
+			close(fd);
+			close(lfd);
+			fprintf(stderr, lbotch);
+			return -1;
+		}
+		*fd2p = fd2;
+	}
+
+	/* get reply */
+	if(read(fd, &c, 1) != 1){
+		if(fd2p)
+			close(fd2);
+		fprintf(stderr, pbotch);
+		return -1;
+	}
+	if(c == 0)
+		return fd;
+	i = 0;
+	while(c){
+		buf[i++] = c;
+		if(read(fd, &c, 1) != 1)
+			break;
+		if(i >= sizeof(buf)-1)
+			break;
+	}
+	buf[i] = 0;
+	fprintf(stderr, "rcmd: %s\n", buf);
+	close(fd);
+	return -1;
+}
diff --git a/sys/src/ape/lib/bsd/readv.c b/sys/src/ape/lib/bsd/readv.c
new file mode 100755
index 000000000..91a7157d0
--- /dev/null
+++ b/sys/src/ape/lib/bsd/readv.c
@@ -0,0 +1,30 @@
+#include <unistd.h>
+#include <string.h>
+#include <sys/uio.h>
+
+int
+readv(int fd, struct iovec *v, int ent)
+{
+	int x, i, n, len;
+	char *t;
+	char buf[10*1024];
+
+	for(len = i = 0; i < ent; i++)
+		len += v[i].iov_len;
+	if(len > sizeof(buf))
+		len = sizeof(buf);
+
+	len = read(fd, buf, len);
+	if(len <= 0)
+		return len;
+
+	for(n = i = 0; n < len && i < ent; i++){
+		x = len - n;
+		if(x > v[i].iov_len)
+			x = v[i].iov_len;
+		memmove(v[i].iov_base, buf + n, x);
+		n += x;
+	}
+
+	return len;
+}
diff --git a/sys/src/ape/lib/bsd/rresvport.c b/sys/src/ape/lib/bsd/rresvport.c
new file mode 100755
index 000000000..6df09c87d
--- /dev/null
+++ b/sys/src/ape/lib/bsd/rresvport.c
@@ -0,0 +1,37 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+/* socket extensions */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+int
+rresvport(int *p)
+{
+	int fd;
+	short i;
+	struct	sockaddr_in in;
+	static int next;
+
+	fd = socket(PF_INET, SOCK_STREAM, 0);
+	if(fd < 0)
+		return -1;
+	i = 600 + ((getpid()+next++)%(1024-600));
+	memset(&in, 0, sizeof(in));
+	in.sin_family = AF_INET;
+	in.sin_port = htons(i);
+printf("in.sin_port = %d\n", in.sin_port);
+	if(bind(fd, &in, sizeof(in)) < 0){
+		close(fd);
+		return -1;
+	}
+	if(p)
+		*p = i;
+	return fd;
+}
diff --git a/sys/src/ape/lib/bsd/send.c b/sys/src/ape/lib/bsd/send.c
new file mode 100755
index 000000000..e46346a03
--- /dev/null
+++ b/sys/src/ape/lib/bsd/send.c
@@ -0,0 +1,31 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#include "priv.h"
+
+int
+send(int fd, char *a, int n, int flags)
+{
+	if(flags & MSG_OOB){
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+	return write(fd, a, n);
+}
+
+int
+recv(int fd, char *a, int n, int flags)
+{
+	if(flags & MSG_OOB){
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+	return read(fd, a, n);
+}
diff --git a/sys/src/ape/lib/bsd/sendto.c b/sys/src/ape/lib/bsd/sendto.c
new file mode 100755
index 000000000..0ab450471
--- /dev/null
+++ b/sys/src/ape/lib/bsd/sendto.c
@@ -0,0 +1,28 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#include "priv.h"
+
+int
+sendto(int fd, void *a, int n, int flags,
+	void *to, int tolen)
+{
+	/* actually, should do connect if not done already */
+	return send(fd, a, n, flags);
+}
+
+int
+recvfrom(int fd, void *a, int n, int flags,
+	void *from, int *fromlen)
+{
+	if(getsockname(fd, from, fromlen) < 0)
+		return -1;
+	return recv(fd, a, n, flags);
+}
diff --git a/sys/src/ape/lib/bsd/sethostent.c b/sys/src/ape/lib/bsd/sethostent.c
new file mode 100755
index 000000000..73867c96b
--- /dev/null
+++ b/sys/src/ape/lib/bsd/sethostent.c
@@ -0,0 +1,5 @@
+int
+sethostent(int)
+{
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/setlinebuf.c b/sys/src/ape/lib/bsd/setlinebuf.c
new file mode 100755
index 000000000..acc907e8d
--- /dev/null
+++ b/sys/src/ape/lib/bsd/setlinebuf.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+void
+setlinebuf(FILE *f)
+{
+	static char buf[BUFSIZ];
+
+	setvbuf (f, buf, _IOLBF, BUFSIZ);
+}
diff --git a/sys/src/ape/lib/bsd/shutdown.c b/sys/src/ape/lib/bsd/shutdown.c
new file mode 100755
index 000000000..dcb15a847
--- /dev/null
+++ b/sys/src/ape/lib/bsd/shutdown.c
@@ -0,0 +1,11 @@
+#include <sys/types.h>
+#include <unistd.h>
+
+int
+shutdown(int fd, int how)
+{
+	if(how == 2)
+		close(fd);
+
+	return 0;
+}
diff --git a/sys/src/ape/lib/bsd/socket.c b/sys/src/ape/lib/bsd/socket.c
new file mode 100755
index 000000000..6623936b8
--- /dev/null
+++ b/sys/src/ape/lib/bsd/socket.c
@@ -0,0 +1,175 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#include "priv.h"
+
+Rock *_sock_rock;
+
+Rock*
+_sock_findrock(int fd, struct stat *dp)
+{
+	Rock *r;
+	struct stat d;
+
+	if(dp == 0)
+		dp = &d;
+	fstat(fd, dp);
+	for(r = _sock_rock; r; r = r->next){
+		if(r->inode == dp->st_ino
+		&& r->dev == dp->st_dev)
+			break;
+	}
+	return r;
+}
+
+Rock*
+_sock_newrock(int fd)
+{
+	Rock *r;
+	struct stat d;
+
+	r = _sock_findrock(fd, &d);
+	if(r == 0){
+		r = malloc(sizeof(Rock));
+		if(r == 0)
+			return 0;
+		r->dev = d.st_dev;
+		r->inode = d.st_ino;
+		r->other = -1;
+		r->next = _sock_rock;
+		_sock_rock = r;
+	}
+	memset(&r->raddr, 0, sizeof(r->raddr));
+	memset(&r->addr, 0, sizeof(r->addr));
+	r->reserved = 0;
+	r->dev = d.st_dev;
+	r->inode = d.st_ino;
+	r->other = -1;
+	return r;
+}
+
+int
+_sock_data(int cfd, char *net, int domain, int stype, int protocol, Rock **rp)
+{
+	int n, fd;
+	Rock *r;
+	char name[Ctlsize];
+
+	/* get the data file name */
+	n = read(cfd, name, sizeof(name)-1);
+	if(n < 0){
+		close(cfd);
+		errno = ENOBUFS;
+		return -1;
+	}
+	name[n] = 0;
+	n = strtoul(name, 0, 0);
+	snprintf(name, sizeof name, "/net/%s/%d/data", net, n);
+
+	/* open data file */
+	fd = open(name, O_RDWR);
+	close(cfd);
+	if(fd < 0){
+		close(cfd);
+		errno = ENOBUFS;
+		return -1;
+	}
+
+	/* hide stuff under the rock */
+	snprintf(name, sizeof name, "/net/%s/%d/ctl", net, n);
+	r = _sock_newrock(fd);
+	if(r == 0){
+		errno = ENOBUFS;
+		close(fd);
+		return -1;
+	}
+	if(rp)
+		*rp = r;
+	memset(&r->raddr, 0, sizeof(r->raddr));
+	memset(&r->addr, 0, sizeof(r->addr));
+	r->domain = domain;
+	r->stype = stype;
+	r->protocol = protocol;
+	strcpy(r->ctl, name);
+	return fd;
+}
+
+int
+socket(int domain, int stype, int protocol)
+{
+	Rock *r;
+	int cfd, fd, n;
+	int pfd[2];
+	char *net;
+
+	switch(domain){
+	case PF_INET:
+		/* get a free network directory */
+		switch(stype){
+		case SOCK_DGRAM:
+			net = "udp";
+			cfd = open("/net/udp/clone", O_RDWR);
+			break;
+		case SOCK_STREAM:
+			net = "tcp";
+			cfd = open("/net/tcp/clone", O_RDWR);
+			break;
+		default:
+			errno = EPROTONOSUPPORT;
+			return -1;
+		}
+		if(cfd < 0){
+			_syserrno();
+			return -1;
+		}
+		return _sock_data(cfd, net, domain, stype, protocol, 0);
+	case PF_UNIX:
+		if(pipe(pfd) < 0){
+			_syserrno();
+			return -1;
+		}
+		r = _sock_newrock(pfd[0]);
+		r->domain = domain;
+		r->stype = stype;
+		r->protocol = protocol;
+		r->other = pfd[1];
+		return pfd[0];
+	default:
+		errno = EPROTONOSUPPORT;
+		return -1;
+	}
+}
+
+int
+issocket(int fd)
+{
+	Rock *r;
+
+	r = _sock_findrock(fd, 0);
+	return (r != 0);
+}
+
+/*
+ * probably should do better than this
+ */
+int getsockopt(int, int, int, void *, int *)
+{
+	return -1;
+}
+
+int setsockopt(int, int, int, void *, int)
+{
+	return 0;
+}
+
diff --git a/sys/src/ape/lib/bsd/socketpair.c b/sys/src/ape/lib/bsd/socketpair.c
new file mode 100755
index 000000000..990c3f77f
--- /dev/null
+++ b/sys/src/ape/lib/bsd/socketpair.c
@@ -0,0 +1,21 @@
+/* posix */
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+int
+socketpair(int domain, int type, int protocol, int *sv)
+{
+	switch(domain){
+	case PF_UNIX:
+		return pipe(sv);
+	default:
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+}
diff --git a/sys/src/ape/lib/bsd/strcasecmp.c b/sys/src/ape/lib/bsd/strcasecmp.c
new file mode 100755
index 000000000..7fb8c8a80
--- /dev/null
+++ b/sys/src/ape/lib/bsd/strcasecmp.c
@@ -0,0 +1,28 @@
+#include <string.h>
+
+typedef unsigned char uchar;
+
+
+int
+strcasecmp(char *s1, char *s2)
+{
+	int c1, c2;
+
+	while(*s1){
+		c1 = *(uchar*)s1++;
+		c2 = *(uchar*)s2++;
+
+		if(c1 == c2)
+			continue;
+
+		if(c1 >= 'A' && c1 <= 'Z')
+			c1 -= 'A' - 'a';
+
+		if(c2 >= 'A' && c2 <= 'Z')
+			c2 -= 'A' - 'a';
+
+		if(c1 != c2)
+			return c1 - c2;
+	}
+	return -*s2;
+}
diff --git a/sys/src/ape/lib/bsd/strdup.c b/sys/src/ape/lib/bsd/strdup.c
new file mode 100755
index 000000000..5e4a3759e
--- /dev/null
+++ b/sys/src/ape/lib/bsd/strdup.c
@@ -0,0 +1,16 @@
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+char*
+strdup(char *p)
+{
+	int n;
+	char *np;
+
+	n = strlen(p)+1;
+	np = malloc(n);
+	if(np)
+		memmove(np, p, n);
+	return np;
+}
diff --git a/sys/src/ape/lib/bsd/strncasecmp.c b/sys/src/ape/lib/bsd/strncasecmp.c
new file mode 100755
index 000000000..a9ddc8dee
--- /dev/null
+++ b/sys/src/ape/lib/bsd/strncasecmp.c
@@ -0,0 +1,29 @@
+#include <string.h>
+
+typedef unsigned char uchar;
+
+int
+strncasecmp(char *s1, char *s2, int n)
+{
+	int c1, c2;
+
+	while(*s1 && n-- > 0){
+		c1 = *(uchar*)s1++;
+		c2 = *(uchar*)s2++;
+
+		if(c1 == c2)
+			continue;
+
+		if(c1 >= 'A' && c1 <= 'Z')
+			c1 -= 'A' - 'a';
+
+		if(c2 >= 'A' && c2 <= 'Z')
+			c2 -= 'A' - 'a';
+
+		if(c1 != c2)
+			return c1 - c2;
+	}
+	if(n <= 0)
+		return 0;
+	return -*s2;
+}
diff --git a/sys/src/ape/lib/bsd/writev.c b/sys/src/ape/lib/bsd/writev.c
new file mode 100755
index 000000000..fbb36b692
--- /dev/null
+++ b/sys/src/ape/lib/bsd/writev.c
@@ -0,0 +1,62 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+
+/* bsd extensions */
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#include "priv.h"
+
+int
+writev(int fd, struct iovec *v, int ent)
+{
+	int i, n, written;
+	char *t, *e, *f;
+	char buf[10*1024];
+
+	written = n = 0;
+	t = buf;
+	e = buf+sizeof(buf);
+	for(;ent ; v++, ent--){
+		n = v->iov_len;
+		f = v->iov_base;
+		while(n > 0){
+			i = e-t;
+			if(n < i){
+				memmove(t, f, n);
+				t += n;
+				break;
+			}
+			memmove(t, f, i);
+			n -= i;
+			f += i;
+			i = write(fd, buf, sizeof(buf));
+			if(i < 0){
+				if(written > 0){
+					return written;
+				}else{
+					_syserrno();
+					return -1;
+				}
+			}
+			written += i;
+			if(i != sizeof(buf)) {
+				return written;
+			}
+			t = buf;
+		}
+	}
+	i = t - buf;
+	if(i > 0){
+		n = write(fd, buf, i);
+		if(n < 0){
+			if(written == 0){
+				_syserrno();
+				return -1;
+			}
+		} else
+			written += n;
+	}
+	return written;
+}
diff --git a/sys/src/ape/lib/draw/colors.c b/sys/src/ape/lib/draw/colors.c
new file mode 100755
index 000000000..2f668cdc3
--- /dev/null
+++ b/sys/src/ape/lib/draw/colors.c
@@ -0,0 +1,203 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+
+char *argv0;
+
+static void
+_sysfatalimpl(char *fmt, va_list arg)
+{
+	char buf[1024];
+
+	vseprint(buf, buf+sizeof(buf), fmt, arg);
+	if(argv0)
+		fprint(2, "%s: %s\n", argv0, buf);
+	else
+		fprint(2, "%s\n", buf);
+	exits(buf);
+}
+
+void (*_sysfatal)(char *fmt, va_list arg) = _sysfatalimpl;
+
+void
+sysfatal(char *fmt, ...)
+{
+	va_list arg;
+
+	va_start(arg, fmt);
+	(*_sysfatal)(fmt, arg);
+	va_end(arg);
+}
+
+int nbit, npix;
+Image *pixel;
+Rectangle crect[256];
+
+Image *color[256];
+
+void
+eresized(int new)
+{
+	int x, y, i, n, nx, ny;
+	Rectangle r, b;
+
+	if(new && getwindow(display, Refnone) < 0){
+		fprint(2, "colors: can't reattach to window: %r\n");
+		exits("resized");
+	}
+	if(screen->depth > 8){
+		n = 256;
+		nx = 16;
+	}else{
+		n = 1<<screen->depth;
+		nx = 1<<(screen->depth/2);
+	}
+
+	ny = n/nx;
+	draw(screen, screen->r, display->white, nil, ZP);
+	r = insetrect(screen->r, 5);
+	r.min.y+=20;
+	b.max.y=r.min.y;
+	for(i=n-1, y=0; y!=ny; y++){
+		b.min.y=b.max.y;
+		b.max.y=r.min.y+(r.max.y-r.min.y)*(y+1)/ny;
+		b.max.x=r.min.x;
+		for(x=0; x!=nx; x++, --i){
+			b.min.x=b.max.x;
+			b.max.x=r.min.x+(r.max.x-r.min.x)*(x+1)/nx;
+			crect[i]=insetrect(b, 1);
+			draw(screen, crect[i], color[i], nil, ZP);
+		}
+	}
+	flushimage(display, 1);
+}
+
+char *buttons[] =
+{
+	"exit",
+	0
+};
+
+ulong
+grey(int i)
+{
+	if(i < 0)
+		return grey(0);
+	if(i > 255)
+		return grey(255);
+	return (i<<16)+(i<<8)+i;
+}
+
+Menu menu =
+{
+	buttons
+};
+
+int
+dither[16] =  {
+	0, 8, 2, 10,
+	12, 4, 14, 6,
+	3, 11, 1, 9,
+	15, 7, 13, 5
+};
+
+void
+main(int argc, char *argv[])
+{
+	Point p;
+	Mouse m;
+	int i, j, k, l, n, ramp, prev;
+	char buf[100];
+	char *fmt;
+	Image *dark;
+	ulong rgb;
+
+	ramp = 0;
+
+	fmt = "index %3d r %3lud g %3lud b %3lud 0x%.8luX        ";
+/*
+	ARGBEGIN{
+	default:
+		goto Usage;
+	case 'x':
+		fmt = "index %2luX r %3luX g %3luX b %3luX 0x%.8luX       ";
+		break;
+	case 'r':
+		ramp = 1;
+		break;
+	}ARGEND
+*/
+	argv0 = argv[0];
+	if(argc != 1){
+	Usage:
+		fprint(2, "Usage: %s [-rx]\n", argv0);
+		exits("usage");
+	}
+
+	if(initdraw(nil, nil, "colors") < 0)
+		sysfatal("initdraw failed: %r");
+	einit(Emouse);
+
+	for(i=0; i<256; i++){
+		if(ramp){
+			if(screen->chan == CMAP8){
+				/* dither the fine grey */
+				j = i-(i%17);
+				dark = allocimage(display, Rect(0,0,1,1), screen->chan, 1, (grey(j)<<8)+0xFF);
+				color[i] = allocimage(display, Rect(0,0,4,4), screen->chan, 1, (grey(j+17)<<8)+0xFF);
+				for(j=0; j<16; j++){
+					k = j%4;
+					l = j/4;
+					if(dither[j] > (i%17))
+						draw(color[i], Rect(k, l, k+1, l+1), dark, nil, ZP);
+				}
+				freeimage(dark);
+			}else
+				color[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, (grey(i)<<8)+0xFF);
+		}else
+			color[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, (cmap2rgb(i)<<8)+0xFF);
+		if(color[i] == nil)
+			sysfatal("can't allocate image: %r");
+	}
+	eresized(0);
+	prev = -1;
+	for(;;){
+		m = emouse();
+		switch(m.buttons){
+		case 1:
+			while(m.buttons){
+				if(screen->depth > 8)
+					n = 256;
+				else
+					n = 1<<screen->depth;
+				for(i=0; i!=n; i++)
+					if(i!=prev && ptinrect(m.xy, crect[i])){
+						if(ramp)
+							rgb = grey(i);
+						else
+							rgb = cmap2rgb(i);
+						sprint(buf, fmt,
+							i,
+							(rgb>>16)&0xFF,
+							(rgb>>8)&0xFF,
+							rgb&0xFF,
+							(rgb<<8) | 0xFF);
+						p = addpt(screen->r.min, Pt(2,2));
+						draw(screen, Rpt(p, addpt(p, stringsize(font, buf))), display->white, nil, p);
+						string(screen, p, display->black, ZP, font, buf);
+						prev=i;
+						break;
+					}
+				m = emouse();
+			}
+			break;
+
+		case 4:
+			switch(emenuhit(3, &m, &menu)){
+			case 0:
+				exits(0);
+			}
+		}
+	}
+}
diff --git a/sys/src/ape/lib/draw/libc.h b/sys/src/ape/lib/draw/libc.h
new file mode 100755
index 000000000..97e3deacb
--- /dev/null
+++ b/sys/src/ape/lib/draw/libc.h
@@ -0,0 +1,137 @@
+#define _LOCK_EXTENSION
+#define _QLOCK_EXTENSION
+#define _BSD_EXTENSION
+#include <sys/types.h>
+#include <lock.h>
+#include <qlock.h>
+#include <lib9.h>
+#include <stdlib.h>
+#include <string.h>
+#include <bsd.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <utf.h>
+#include <fmt.h>
+#include <signal.h>
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length: see <u.h> */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+uint	_convM2D(uchar*, uint, Dir*, char*);
+uint	_convD2M(Dir*, uchar*, uint);
+Dir	*_dirstat(char*);
+int	_dirwstat(char*, Dir*);
+Dir	*_dirfstat(int);
+int	_dirfwstat(int, Dir*);
+long	_dirread(int, Dir**);
+long _dirreadall(int, Dir**);
+void _nulldir(Dir*);
+uint _sizeD2M(Dir*);
+
+typedef
+struct Waitmsg
+{
+	int pid;	/* of loved one */
+	unsigned long time[3];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+
+extern	int	_AWAIT(char*, int);
+extern	int	_ALARM(unsigned long);
+extern	int	_BIND(const char*, const char*, int);
+extern	int	_CHDIR(const char*);
+extern	int	_CLOSE(int);
+extern	int	_CREATE(char*, int, unsigned long);
+extern	int	_DUP(int, int);
+extern	int	_ERRSTR(char*, unsigned int);
+extern	int	_EXEC(char*, char*[]);
+extern	void	_EXITS(char *);
+extern	int	_FD2PATH(int, char*, int);
+extern	int	_FAUTH(int, char*);
+extern	int	_FSESSION(int, char*, int);
+extern	int	_FSTAT(int, unsigned char*, int);
+extern	int	_FWSTAT(int, unsigned char*, int);
+extern	int	_MOUNT(int, int, const char*, int, const char*);
+extern	int	_NOTED(int);
+extern	int	_NOTIFY(int(*)(void*, char*));
+extern	int	_OPEN(const char*, int);
+extern	int	_PIPE(int*);
+extern	long	_PREAD(int, void*, long, long long);
+extern	long	_PWRITE(int, void*, long, long long);
+extern	long	_READ(int, void*, long);
+extern	int	_REMOVE(const char*);
+extern	int	_RENDEZVOUS(unsigned long, unsigned long);
+extern	int	_RFORK(int);
+extern	int	_SEGATTACH(int, char*, void*, unsigned long);
+extern	int	_SEGBRK(void*, void*);
+extern	int	_SEGDETACH(void*);
+extern	int	_SEGFLUSH(void*, unsigned long);
+extern	int	_SEGFREE(void*, unsigned long);
+extern	long long	_SEEK(int, long long, int);
+extern	int	_SLEEP(long);
+extern	int	_STAT(const char*, unsigned char*, int);
+extern	Waitmsg*	_WAIT(void);
+extern	long	_WRITE(int, const void*, long);
+extern	int	_WSTAT(const char*, unsigned char*, int);
+extern 	void *_MALLOCZ(int, int);
+extern	int	_WERRSTR(char*, ...);
+extern	long	_READN(int, void*, long);
+extern	int	_IOUNIT(int);
+
+#define dirstat _dirstat
+#define dirfstat _dirfstat
+
+#define OREAD 0
+#define OWRITE 1
+#define ORDWR 2
+#define OCEXEC 32
+
+#define AREAD 4
+#define AWRITE 2
+#define AEXEC 1
+#define AEXIST 0
+
+#define open _OPEN
+#define close _CLOSE
+#define read _READ
+#define write _WRITE
+#define _exits(s) _exit(s && *(char*)s ? 1 : 0)
+#define exits(s) exit(s && *(char*)s ? 1 : 0)
+#define create _CREATE
+#define pread _PREAD
+#define readn _READN
+#define mallocz _MALLOCZ
+#define iounit	_IOUNIT
+
+/* assume being called as in event.c */
+#define postnote(x, pid, msg) kill(pid, SIGTERM)
+#define atnotify(x, y) signal(SIGTERM, ekill)
+
+#define ERRMAX 128
+
+extern	void	setmalloctag(void*, ulong);
+extern	ulong	getcallerpc(void*);
diff --git a/sys/src/ape/lib/draw/mkfile b/sys/src/ape/lib/draw/mkfile
new file mode 100755
index 000000000..278b186b8
--- /dev/null
+++ b/sys/src/ape/lib/draw/mkfile
@@ -0,0 +1,78 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libdraw.a
+
+OFILES=\
+	alloc.$O\
+	allocimagemix.$O\
+	arith.$O\
+	bezier.$O\
+	border.$O\
+	buildfont.$O\
+	bytesperline.$O\
+	chan.$O\
+	cloadimage.$O\
+	computil.$O\
+	creadimage.$O\
+	debug.$O\
+	defont.$O\
+	draw.$O\
+	drawrepl.$O\
+	egetrect.$O\
+	ellipse.$O\
+	emenuhit.$O\
+	event.$O\
+	fmt.$O\
+	font.$O\
+	freesubfont.$O\
+	getdefont.$O\
+	getsubfont.$O\
+	icossin.$O\
+	icossin2.$O\
+	init.$O\
+	line.$O\
+	mkfont.$O\
+	newwindow.$O\
+	openfont.$O\
+	poly.$O\
+	loadimage.$O\
+	readimage.$O\
+	readsubfont.$O\
+	rectclip.$O\
+	replclipr.$O\
+	rgb.$O\
+	string.$O\
+	stringbg.$O\
+	stringsubfont.$O\
+	stringwidth.$O\
+	subfont.$O\
+	subfontcache.$O\
+	subfontname.$O\
+	unloadimage.$O\
+	window.$O\
+	writecolmap.$O\
+	writeimage.$O\
+	writesubfont.$O\
+
+HFILES=\
+	/sys/include/ape/draw.h\
+	/sys/include/ape/event.h\
+	/sys/include/ape/mouse.h\
+	/sys/include/ape/keyboard.h\
+
+UPDATE=\
+	mkfile\
+	$HFILES\
+	${OFILES:%.$O=%.c}\
+	${LIB:/$objtype/%=/386/%}\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c $CFLAGS -D_POSIX_SOURCE -D_PLAN9_SOURCE -I.
+
+%.$O: /sys/src/libdraw/%.c
+	$CC $CFLAGS /sys/src/libdraw/$stem.c
+
+$O.colors: colors.$O
+	$LD -o $target colors.$O
diff --git a/sys/src/ape/lib/fmt/charstod.c b/sys/src/ape/lib/fmt/charstod.c
new file mode 100755
index 000000000..ec403b11b
--- /dev/null
+++ b/sys/src/ape/lib/fmt/charstod.c
@@ -0,0 +1,85 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * Reads a floating-point number by interpreting successive characters
+ * returned by (*f)(vp).  The last call it makes to f terminates the
+ * scan, so is not a character in the number.  It may therefore be
+ * necessary to back up the input stream up one byte after calling charstod.
+ */
+
+double
+fmtcharstod(int(*f)(void*), void *vp)
+{
+	double num, dem;
+	int neg, eneg, dig, exp, c;
+
+	num = 0;
+	neg = 0;
+	dig = 0;
+	exp = 0;
+	eneg = 0;
+
+	c = (*f)(vp);
+	while(c == ' ' || c == '\t')
+		c = (*f)(vp);
+	if(c == '-' || c == '+'){
+		if(c == '-')
+			neg = 1;
+		c = (*f)(vp);
+	}
+	while(c >= '0' && c <= '9'){
+		num = num*10 + c-'0';
+		c = (*f)(vp);
+	}
+	if(c == '.')
+		c = (*f)(vp);
+	while(c >= '0' && c <= '9'){
+		num = num*10 + c-'0';
+		dig++;
+		c = (*f)(vp);
+	}
+	if(c == 'e' || c == 'E'){
+		c = (*f)(vp);
+		if(c == '-' || c == '+'){
+			if(c == '-'){
+				dig = -dig;
+				eneg = 1;
+			}
+			c = (*f)(vp);
+		}
+		while(c >= '0' && c <= '9'){
+			exp = exp*10 + c-'0';
+			c = (*f)(vp);
+		}
+	}
+	exp -= dig;
+	if(exp < 0){
+		exp = -exp;
+		eneg = !eneg;
+	}
+	dem = __fmtpow10(exp);
+	if(eneg)
+		num /= dem;
+	else
+		num *= dem;
+	if(neg)
+		return -num;
+	return num;
+}
diff --git a/sys/src/ape/lib/fmt/dofmt.c b/sys/src/ape/lib/fmt/dofmt.c
new file mode 100755
index 000000000..014b66257
--- /dev/null
+++ b/sys/src/ape/lib/fmt/dofmt.c
@@ -0,0 +1,557 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/* format the output into f->to and return the number of characters fmted  */
+int
+dofmt(Fmt *f, char *fmt)
+{
+	Rune rune, *rt, *rs;
+	int r;
+	char *t, *s;
+	int n, nfmt;
+
+	nfmt = f->nfmt;
+	for(;;){
+		if(f->runes){
+			rt = (Rune*)f->to;
+			rs = (Rune*)f->stop;
+			while((r = *(uchar*)fmt) && r != '%'){
+				if(r < Runeself)
+					fmt++;
+				else{
+					fmt += chartorune(&rune, fmt);
+					r = rune;
+				}
+				FMTRCHAR(f, rt, rs, r);
+			}
+			fmt++;
+			f->nfmt += rt - (Rune *)f->to;
+			f->to = rt;
+			if(!r)
+				return f->nfmt - nfmt;
+			f->stop = rs;
+		}else{
+			t = (char*)f->to;
+			s = (char*)f->stop;
+			while((r = *(uchar*)fmt) && r != '%'){
+				if(r < Runeself){
+					FMTCHAR(f, t, s, r);
+					fmt++;
+				}else{
+					n = chartorune(&rune, fmt);
+					if(t + n > s){
+						t = (char*)__fmtflush(f, t, n);
+						if(t != nil)
+							s = (char*)f->stop;
+						else
+							return -1;
+					}
+					while(n--)
+						*t++ = *fmt++;
+				}
+			}
+			fmt++;
+			f->nfmt += t - (char *)f->to;
+			f->to = t;
+			if(!r)
+				return f->nfmt - nfmt;
+			f->stop = s;
+		}
+
+		fmt = (char*)__fmtdispatch(f, fmt, 0);
+		if(fmt == nil)
+			return -1;
+	}
+}
+
+void *
+__fmtflush(Fmt *f, void *t, int len)
+{
+	if(f->runes)
+		f->nfmt += (Rune*)t - (Rune*)f->to;
+	else
+		f->nfmt += (char*)t - (char *)f->to;
+	f->to = t;
+	if(f->flush == 0 || (*f->flush)(f) == 0 || (char*)f->to + len > (char*)f->stop){
+		f->stop = f->to;
+		return nil;
+	}
+	return f->to;
+}
+
+/*
+ * put a formatted block of memory sz bytes long of n runes into the output buffer,
+ * left/right justified in a field of at least f->width charactes
+ */
+int
+__fmtpad(Fmt *f, int n)
+{
+	char *t, *s;
+	int i;
+
+	t = (char*)f->to;
+	s = (char*)f->stop;
+	for(i = 0; i < n; i++)
+		FMTCHAR(f, t, s, ' ');
+	f->nfmt += t - (char *)f->to;
+	f->to = t;
+	return 0;
+}
+
+int
+__rfmtpad(Fmt *f, int n)
+{
+	Rune *t, *s;
+	int i;
+
+	t = (Rune*)f->to;
+	s = (Rune*)f->stop;
+	for(i = 0; i < n; i++)
+		FMTRCHAR(f, t, s, ' ');
+	f->nfmt += t - (Rune *)f->to;
+	f->to = t;
+	return 0;
+}
+
+int
+__fmtcpy(Fmt *f, const void *vm, int n, int sz)
+{
+	Rune *rt, *rs, r;
+	char *t, *s, *m, *me;
+	ulong fl;
+	int nc, w;
+
+	m = (char*)vm;
+	me = m + sz;
+	w = f->width;
+	fl = f->flags;
+	if((fl & FmtPrec) && n > f->prec)
+		n = f->prec;
+	if(f->runes){
+		if(!(fl & FmtLeft) && __rfmtpad(f, w - n) < 0)
+			return -1;
+		rt = (Rune*)f->to;
+		rs = (Rune*)f->stop;
+		for(nc = n; nc > 0; nc--){
+			r = *(uchar*)m;
+			if(r < Runeself)
+				m++;
+			else if((me - m) >= UTFmax || fullrune(m, me-m))
+				m += chartorune(&r, m);
+			else
+				break;
+			FMTRCHAR(f, rt, rs, r);
+		}
+		f->nfmt += rt - (Rune *)f->to;
+		f->to = rt;
+		if(m < me)
+			return -1;
+		if(fl & FmtLeft && __rfmtpad(f, w - n) < 0)
+			return -1;
+	}else{
+		if(!(fl & FmtLeft) && __fmtpad(f, w - n) < 0)
+			return -1;
+		t = (char*)f->to;
+		s = (char*)f->stop;
+		for(nc = n; nc > 0; nc--){
+			r = *(uchar*)m;
+			if(r < Runeself)
+				m++;
+			else if((me - m) >= UTFmax || fullrune(m, me-m))
+				m += chartorune(&r, m);
+			else
+				break;
+			FMTRUNE(f, t, s, r);
+		}
+		f->nfmt += t - (char *)f->to;
+		f->to = t;
+		if(fl & FmtLeft && __fmtpad(f, w - n) < 0)
+			return -1;
+	}
+	return 0;
+}
+
+int
+__fmtrcpy(Fmt *f, const void *vm, int n)
+{
+	Rune r, *m, *me, *rt, *rs;
+	char *t, *s;
+	ulong fl;
+	int w;
+
+	m = (Rune*)vm;
+	w = f->width;
+	fl = f->flags;
+	if((fl & FmtPrec) && n > f->prec)
+		n = f->prec;
+	if(f->runes){
+		if(!(fl & FmtLeft) && __rfmtpad(f, w - n) < 0)
+			return -1;
+		rt = (Rune*)f->to;
+		rs = (Rune*)f->stop;
+		for(me = m + n; m < me; m++)
+			FMTRCHAR(f, rt, rs, *m);
+		f->nfmt += rt - (Rune *)f->to;
+		f->to = rt;
+		if(fl & FmtLeft && __rfmtpad(f, w - n) < 0)
+			return -1;
+	}else{
+		if(!(fl & FmtLeft) && __fmtpad(f, w - n) < 0)
+			return -1;
+		t = (char*)f->to;
+		s = (char*)f->stop;
+		for(me = m + n; m < me; m++){
+			r = *m;
+			FMTRUNE(f, t, s, r);
+		}
+		f->nfmt += t - (char *)f->to;
+		f->to = t;
+		if(fl & FmtLeft && __fmtpad(f, w - n) < 0)
+			return -1;
+	}
+	return 0;
+}
+
+/* fmt out one character */
+int
+__charfmt(Fmt *f)
+{
+	char x[1];
+
+	x[0] = va_arg(f->args, int);
+	f->prec = 1;
+	return __fmtcpy(f, (const char*)x, 1, 1);
+}
+
+/* fmt out one rune */
+int
+__runefmt(Fmt *f)
+{
+	Rune x[1];
+
+	x[0] = va_arg(f->args, int);
+	return __fmtrcpy(f, (const void*)x, 1);
+}
+
+/* public helper routine: fmt out a null terminated string already in hand */
+int
+fmtstrcpy(Fmt *f, char *s)
+{
+	int p, i;
+	if(!s)
+		return __fmtcpy(f, "<nil>", 5, 5);
+	/* if precision is specified, make sure we don't wander off the end */
+	if(f->flags & FmtPrec){
+		p = f->prec;
+		for(i = 0; i < p; i++)
+			if(s[i] == 0)
+				break;
+		return __fmtcpy(f, s, utfnlen(s, i), i);	/* BUG?: won't print a partial rune at end */
+	}
+
+	return __fmtcpy(f, s, utflen(s), strlen(s));
+}
+
+/* fmt out a null terminated utf string */
+int
+__strfmt(Fmt *f)
+{
+	char *s;
+
+	s = va_arg(f->args, char *);
+	return fmtstrcpy(f, s);
+}
+
+/* public helper routine: fmt out a null terminated rune string already in hand */
+int
+fmtrunestrcpy(Fmt *f, Rune *s)
+{
+	Rune *e;
+	int n, p;
+
+	if(!s)
+		return __fmtcpy(f, "<nil>", 5, 5);
+	/* if precision is specified, make sure we don't wander off the end */
+	if(f->flags & FmtPrec){
+		p = f->prec;
+		for(n = 0; n < p; n++)
+			if(s[n] == 0)
+				break;
+	}else{
+		for(e = s; *e; e++)
+			;
+		n = e - s;
+	}
+	return __fmtrcpy(f, s, n);
+}
+
+/* fmt out a null terminated rune string */
+int
+__runesfmt(Fmt *f)
+{
+	Rune *s;
+
+	s = va_arg(f->args, Rune *);
+	return fmtrunestrcpy(f, s);
+}
+
+/* fmt a % */
+int
+__percentfmt(Fmt *f)
+{
+	Rune x[1];
+
+	x[0] = f->r;
+	f->prec = 1;
+	return __fmtrcpy(f, (const void*)x, 1);
+}
+
+/* fmt an integer */
+int
+__ifmt(Fmt *f)
+{
+	char buf[70], *p, *conv;
+	uvlong vu;
+	ulong u;
+	int neg, base, i, n, fl, w, isv;
+
+	neg = 0;
+	fl = f->flags;
+	isv = 0;
+	vu = 0;
+	u = 0;
+	/*
+	 * Unsigned verbs
+	 */
+	switch(f->r){
+	case 'o':
+	case 'u':
+	case 'x':
+	case 'X':
+		fl |= FmtUnsigned;
+		break;
+	}
+	if(f->r == 'p'){
+		u = (ulong)va_arg(f->args, void*);
+		f->r = 'x';
+		fl |= FmtUnsigned;
+	}else if(fl & FmtVLong){
+		isv = 1;
+		if(fl & FmtUnsigned)
+			vu = va_arg(f->args, uvlong);
+		else
+			vu = va_arg(f->args, vlong);
+	}else if(fl & FmtLong){
+		if(fl & FmtUnsigned)
+			u = va_arg(f->args, ulong);
+		else
+			u = va_arg(f->args, long);
+	}else if(fl & FmtByte){
+		if(fl & FmtUnsigned)
+			u = (uchar)va_arg(f->args, int);
+		else
+			u = (char)va_arg(f->args, int);
+	}else if(fl & FmtShort){
+		if(fl & FmtUnsigned)
+			u = (ushort)va_arg(f->args, int);
+		else
+			u = (short)va_arg(f->args, int);
+	}else{
+		if(fl & FmtUnsigned)
+			u = va_arg(f->args, uint);
+		else
+			u = va_arg(f->args, int);
+	}
+	conv = "0123456789abcdef";
+	switch(f->r){
+	case 'd':
+	case 'i':
+		base = 10;
+		break;
+	case 'u':
+		base = 10;
+		break;
+	case 'x':
+		base = 16;
+		break;
+	case 'X':
+		base = 16;
+		conv = "0123456789ABCDEF";
+		break;
+	case 'b':
+		base = 2;
+		break;
+	case 'o':
+		base = 8;
+		break;
+	default:
+		return -1;
+	}
+	if(!(fl & FmtUnsigned)){
+		if(isv && (vlong)vu < 0){
+			vu = -(vlong)vu;
+			neg = 1;
+		}else if(!isv && (long)u < 0){
+			u = -(long)u;
+			neg = 1;
+		}
+	}else{
+		fl &= ~(FmtSign|FmtSpace);	/* no + for unsigned conversions */
+	}
+	p = buf + sizeof buf - 1;
+	n = 0;
+	if(isv){
+		while(vu){
+			i = vu % base;
+			vu /= base;
+			if((fl & FmtComma) && n % 4 == 3){
+				*p-- = ',';
+				n++;
+			}
+			*p-- = conv[i];
+			n++;
+		}
+	}else{
+		while(u){
+			i = u % base;
+			u /= base;
+			if((fl & FmtComma) && n % 4 == 3){
+				*p-- = ',';
+				n++;
+			}
+			*p-- = conv[i];
+			n++;
+		}
+	}
+	if(n == 0){
+		if(!(fl & FmtPrec) || f->prec != 0){
+			*p-- = '0';
+			n = 1;
+		}
+		fl &= ~FmtSharp;
+	}
+	for(w = f->prec; n < w && p > buf+3; n++)
+		*p-- = '0';
+	if(neg || (fl & (FmtSign|FmtSpace)))
+		n++;
+	if(fl & FmtSharp){
+		if(base == 16)
+			n += 2;
+		else if(base == 8){
+			if(p[1] == '0')
+				fl &= ~FmtSharp;
+			else
+				n++;
+		}
+	}
+	if((fl & FmtZero) && !(fl & (FmtLeft|FmtPrec))){
+		for(w = f->width; n < w && p > buf+3; n++)
+			*p-- = '0';
+		f->width = 0;
+	}
+	if(fl & FmtSharp){
+		if(base == 16)
+			*p-- = f->r;
+		if(base == 16 || base == 8)
+			*p-- = '0';
+	}
+	if(neg)
+		*p-- = '-';
+	else if(fl & FmtSign)
+		*p-- = '+';
+	else if(fl & FmtSpace)
+		*p-- = ' ';
+	f->flags &= ~FmtPrec;
+	return __fmtcpy(f, p + 1, n, n);
+}
+
+int
+__countfmt(Fmt *f)
+{
+	void *p;
+	ulong fl;
+
+	fl = f->flags;
+	p = va_arg(f->args, void*);
+	if(fl & FmtVLong){
+		*(vlong*)p = f->nfmt;
+	}else if(fl & FmtLong){
+		*(long*)p = f->nfmt;
+	}else if(fl & FmtByte){
+		*(char*)p = f->nfmt;
+	}else if(fl & FmtShort){
+		*(short*)p = f->nfmt;
+	}else{
+		*(int*)p = f->nfmt;
+	}
+	return 0;
+}
+
+int
+__flagfmt(Fmt *f)
+{
+	switch(f->r){
+	case ',':
+		f->flags |= FmtComma;
+		break;
+	case '-':
+		f->flags |= FmtLeft;
+		break;
+	case '+':
+		f->flags |= FmtSign;
+		break;
+	case '#':
+		f->flags |= FmtSharp;
+		break;
+	case ' ':
+		f->flags |= FmtSpace;
+		break;
+	case 'u':
+		f->flags |= FmtUnsigned;
+		break;
+	case 'h':
+		if(f->flags & FmtShort)
+			f->flags |= FmtByte;
+		f->flags |= FmtShort;
+		break;
+	case 'L':
+		f->flags |= FmtLDouble;
+		break;
+	case 'l':
+		if(f->flags & FmtLong)
+			f->flags |= FmtVLong;
+		f->flags |= FmtLong;
+		break;
+	}
+	return 1;
+}
+
+/* default error format */
+int
+__badfmt(Fmt *f)
+{
+	char x[3];
+
+	x[0] = '%';
+	x[1] = f->r;
+	x[2] = '%';
+	f->prec = 3;
+	__fmtcpy(f, (const void*)x, 3, 3);
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/dorfmt.c b/sys/src/ape/lib/fmt/dorfmt.c
new file mode 100755
index 000000000..cdaee8a5f
--- /dev/null
+++ b/sys/src/ape/lib/fmt/dorfmt.c
@@ -0,0 +1,61 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/* format the output into f->to and return the number of characters fmted  */
+
+int
+dorfmt(Fmt *f, const Rune *fmt)
+{
+	Rune *rt, *rs;
+	int r;
+	char *t, *s;
+	int nfmt;
+
+	nfmt = f->nfmt;
+	for(;;){
+		if(f->runes){
+			rt = f->to;
+			rs = f->stop;
+			while((r = *fmt++) && r != '%'){
+				FMTRCHAR(f, rt, rs, r);
+			}
+			f->nfmt += rt - (Rune *)f->to;
+			f->to = rt;
+			if(!r)
+				return f->nfmt - nfmt;
+			f->stop = rs;
+		}else{
+			t = f->to;
+			s = f->stop;
+			while((r = *fmt++) && r != '%'){
+				FMTRUNE(f, t, f->stop, r);
+			}
+			f->nfmt += t - (char *)f->to;
+			f->to = t;
+			if(!r)
+				return f->nfmt - nfmt;
+			f->stop = s;
+		}
+
+		fmt = __fmtdispatch(f, fmt, 1);
+		if(fmt == nil)
+			return -1;
+	}
+	return 0;		/* not reached */
+}
diff --git a/sys/src/ape/lib/fmt/errfmt.c b/sys/src/ape/lib/fmt/errfmt.c
new file mode 100755
index 000000000..218470542
--- /dev/null
+++ b/sys/src/ape/lib/fmt/errfmt.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <errno.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+__errfmt(Fmt *f)
+{
+	char *s;
+
+	s = strerror(errno);
+	return fmtstrcpy(f, s);
+}
diff --git a/sys/src/ape/lib/fmt/fltfmt.c b/sys/src/ape/lib/fmt/fltfmt.c
new file mode 100755
index 000000000..234f03d9c
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fltfmt.c
@@ -0,0 +1,610 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+#include "nan.h"
+
+enum
+{
+	FDEFLT	= 6,
+	NSIGNIF	= 17
+};
+
+/*
+ * first few powers of 10, enough for about 1/2 of the
+ * total space for doubles.
+ */
+static double pows10[] =
+{
+	  1e0,   1e1,   1e2,   1e3,   1e4,   1e5,   1e6,   1e7,   1e8,   1e9,  
+	 1e10,  1e11,  1e12,  1e13,  1e14,  1e15,  1e16,  1e17,  1e18,  1e19,  
+	 1e20,  1e21,  1e22,  1e23,  1e24,  1e25,  1e26,  1e27,  1e28,  1e29,  
+	 1e30,  1e31,  1e32,  1e33,  1e34,  1e35,  1e36,  1e37,  1e38,  1e39,  
+	 1e40,  1e41,  1e42,  1e43,  1e44,  1e45,  1e46,  1e47,  1e48,  1e49,  
+	 1e50,  1e51,  1e52,  1e53,  1e54,  1e55,  1e56,  1e57,  1e58,  1e59,  
+	 1e60,  1e61,  1e62,  1e63,  1e64,  1e65,  1e66,  1e67,  1e68,  1e69,  
+	 1e70,  1e71,  1e72,  1e73,  1e74,  1e75,  1e76,  1e77,  1e78,  1e79,  
+	 1e80,  1e81,  1e82,  1e83,  1e84,  1e85,  1e86,  1e87,  1e88,  1e89,  
+	 1e90,  1e91,  1e92,  1e93,  1e94,  1e95,  1e96,  1e97,  1e98,  1e99,  
+	1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, 
+	1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 
+	1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 
+	1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 
+	1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 
+	1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 
+};
+
+static double
+pow10(int n)
+{
+	double d;
+	int neg;
+
+	neg = 0;
+	if(n < 0){
+		if(n < DBL_MIN_10_EXP){
+			return 0.;
+		}
+		neg = 1;
+		n = -n;
+	}else if(n > DBL_MAX_10_EXP){
+		return HUGE_VAL;
+	}
+	if(n < (int)(sizeof(pows10)/sizeof(pows10[0])))
+		d = pows10[n];
+	else{
+		d = pows10[sizeof(pows10)/sizeof(pows10[0]) - 1];
+		for(;;){
+			n -= sizeof(pows10)/sizeof(pows10[0]) - 1;
+			if(n < (int)(sizeof(pows10)/sizeof(pows10[0]))){
+				d *= pows10[n];
+				break;
+			}
+			d *= pows10[sizeof(pows10)/sizeof(pows10[0]) - 1];
+		}
+	}
+	if(neg){
+		return 1./d;
+	}
+	return d;
+}
+
+static int
+xadd(char *a, int n, int v)
+{
+	char *b;
+	int c;
+
+	if(n < 0 || n >= NSIGNIF)
+		return 0;
+	for(b = a+n; b >= a; b--) {
+		c = *b + v;
+		if(c <= '9') {
+			*b = c;
+			return 0;
+		}
+		*b = '0';
+		v = 1;
+	}
+	*a = '1';	/* overflow adding */
+	return 1;
+}
+
+static int
+xsub(char *a, int n, int v)
+{
+	char *b;
+	int c;
+
+	for(b = a+n; b >= a; b--) {
+		c = *b - v;
+		if(c >= '0') {
+			*b = c;
+			return 0;
+		}
+		*b = '9';
+		v = 1;
+	}
+	*a = '9';	/* underflow subtracting */
+	return 1;
+}
+
+static void
+xaddexp(char *p, int e)
+{
+	char se[9];
+	int i;
+
+	*p++ = 'e';
+	if(e < 0) {
+		*p++ = '-';
+		e = -e;
+	}
+	i = 0;
+	while(e) {
+		se[i++] = e % 10 + '0';
+		e /= 10;
+	}
+	if(i == 0) {
+		*p++ = '0';
+	} else {
+		while(i > 0)
+			*p++ = se[--i];
+	}
+	*p++ = '\0';
+}
+
+static char*
+xdodtoa(char *s1, double f, int chr, int prec, int *decpt, int *rsign)
+{
+	char s2[NSIGNIF+10];
+	double g, h;
+	int e, d, i;
+	int c2, sign, oerr;
+
+	if(chr == 'F')
+		chr = 'f';
+	if(prec > NSIGNIF)
+		prec = NSIGNIF;
+	if(prec < 0)
+		prec = 0;
+	if(__isNaN(f)) {
+		*decpt = 9999;
+		*rsign = 0;
+		strcpy(s1, "nan");
+		return &s1[3];
+	}
+	sign = 0;
+	if(f < 0) {
+		f = -f;
+		sign++;
+	}
+	*rsign = sign;
+	if(__isInf(f, 1) || __isInf(f, -1)) {
+		*decpt = 9999;
+		strcpy(s1, "inf");
+		return &s1[3];
+	}
+
+	e = 0;
+	g = f;
+	if(g != 0) {
+		frexp(f, &e);
+		e = (int)(e * .301029995664);
+		if(e >= -150 && e <= +150) {
+			d = 0;
+			h = f;
+		} else {
+			d = e/2;
+			h = f * pow10(-d);
+		}
+		g = h * pow10(d-e);
+		while(g < 1) {
+			e--;
+			g = h * pow10(d-e);
+		}
+		while(g >= 10) {
+			e++;
+			g = h * pow10(d-e);
+		}
+	}
+
+	/*
+	 * convert NSIGNIF digits and convert
+	 * back to get accuracy.
+	 */
+	for(i=0; i<NSIGNIF; i++) {
+		d = (int)g;
+		s1[i] = d + '0';
+		g = (g - d) * 10;
+	}
+	s1[i] = 0;
+
+	/*
+	 * try decimal rounding to eliminate 9s
+	 */
+	c2 = prec + 1;
+	if(chr == 'f')
+		c2 += e;
+	oerr = errno;
+	if(c2 >= NSIGNIF-2) {
+		strcpy(s2, s1);
+		d = e;
+		s1[NSIGNIF-2] = '0';
+		s1[NSIGNIF-1] = '0';
+		xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
+		g = fmtstrtod(s1, nil);
+		if(g == f)
+			goto found;
+		if(xadd(s1, NSIGNIF-3, 1)) {
+			e++;
+			xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
+		}
+		g = fmtstrtod(s1, nil);
+		if(g == f)
+			goto found;
+		strcpy(s1, s2);
+		e = d;
+	}
+
+	/*
+	 * convert back so s1 gets exact answer
+	 */
+	for(d = 0; d < 10; d++) {
+		xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
+		g = fmtstrtod(s1, nil);
+		if(f > g) {
+			if(xadd(s1, NSIGNIF-1, 1))
+				e--;
+			continue;
+		}
+		if(f < g) {
+			if(xsub(s1, NSIGNIF-1, 1))
+				e++;
+			continue;
+		}
+		break;
+	}
+
+found:
+	errno = oerr;
+
+	/*
+	 * sign
+	 */
+	d = 0;
+	i = 0;
+
+	/*
+	 * round & adjust 'f' digits
+	 */
+	c2 = prec + 1;
+	if(chr == 'f'){
+		if(xadd(s1, c2+e, 5))
+			e++;
+		c2 += e;
+		if(c2 < 0){
+			c2 = 0;
+			e = -prec - 1;
+		}
+	}else{
+		if(xadd(s1, c2, 5))
+			e++;
+	}
+	if(c2 > NSIGNIF){
+		c2 = NSIGNIF;
+	}
+
+	*decpt = e + 1;
+
+	/*
+	 * terminate the converted digits
+	 */
+	s1[c2] = '\0';
+	return &s1[c2];
+}
+
+/*
+ * this function works like the standard dtoa, if you want it.
+ */
+#if 0
+static char*
+__dtoa(double f, int mode, int ndigits, int *decpt, int *rsign, char **rve)
+{
+	static char s2[NSIGNIF + 10];
+	char *es;
+	int chr, prec;
+
+	switch(mode) {
+	/* like 'e' */
+	case 2:
+	case 4:
+	case 6:
+	case 8:
+		chr = 'e';
+		break;
+	/* like 'g' */
+	case 0:
+	case 1:
+	default:
+		chr = 'g';
+		break;
+	/* like 'f' */
+	case 3:
+	case 5:
+	case 7:
+	case 9:
+		chr = 'f';
+		break;
+	}
+
+	if(chr != 'f' && ndigits){
+		ndigits--;
+	}
+	prec = ndigits;
+	if(prec > NSIGNIF)
+		prec = NSIGNIF;
+	if(ndigits == 0)
+		prec = NSIGNIF;
+	es = xdodtoa(s2, f, chr, prec, decpt, rsign);
+
+	/*
+	 * strip trailing 0
+	 */
+	for(; es > s2 + 1; es--){
+		if(es[-1] != '0'){
+			break;
+		}
+	}
+	*es = '\0';
+	if(rve != NULL)
+		*rve = es;
+	return s2;
+}
+#endif
+
+static int
+fmtzdotpad(Fmt *f, int n, int pt)
+{
+	char *t, *s;
+	int i;
+	Rune *rt, *rs;
+
+	if(f->runes){
+		rt = (Rune*)f->to;
+		rs = (Rune*)f->stop;
+		for(i = 0; i < n; i++){
+			if(i == pt){
+				FMTRCHAR(f, rt, rs, '.');
+			}
+			FMTRCHAR(f, rt, rs, '0');
+		}
+		f->nfmt += rt - (Rune*)f->to;
+		f->to = rt;
+	}else{
+		t = (char*)f->to;
+		s = (char*)f->stop;
+		for(i = 0; i < n; i++){
+			if(i == pt){
+				FMTCHAR(f, t, s, '.');
+			}
+			FMTCHAR(f, t, s, '0');
+		}
+		f->nfmt += t - (char *)f->to;
+		f->to = t;
+	}
+	return 0;
+}
+
+int
+__efgfmt(Fmt *fmt)
+{
+	double f;
+	char s1[NSIGNIF+10];
+	int e, d, n;
+	int c1, c2, c3, c4, ucase, sign, chr, prec, fl;
+
+	f = va_arg(fmt->args, double);
+	prec = FDEFLT;
+	fl = fmt->flags;
+	fmt->flags = 0;
+	if(fl & FmtPrec)
+		prec = fmt->prec;
+	chr = fmt->r;
+	ucase = 0;
+	if(chr == 'E'){
+		chr = 'e';
+		ucase = 1;
+	}else if(chr == 'F'){
+		chr = 'f';
+		ucase = 1;
+	}else if(chr == 'G'){
+		chr = 'g';
+		ucase = 1;
+	}
+	if(prec > 0 && chr == 'g')
+		prec--;
+	if(prec < 0)
+		prec = 0;
+
+	xdodtoa(s1, f, chr, prec, &e, &sign);
+	e--;
+	if(*s1 == 'i' || *s1 == 'n'){
+		if(ucase){
+			if(*s1 == 'i'){
+				strcpy(s1, "INF");
+			}else{
+				strcpy(s1, "NAN");
+			}
+		}
+		fmt->flags = fl & (FmtWidth|FmtLeft);
+		return __fmtcpy(fmt, (const void*)s1, 3, 3);
+	}
+
+	/*
+	 * copy into final place
+	 * c1 digits of leading '0'
+	 * c2 digits from conversion
+	 * c3 digits of trailing '0'
+	 * c4 digits after '.'
+	 */
+	c1 = 0;
+	c2 = prec + 1;
+	c3 = 0;
+	c4 = prec;
+	switch(chr) {
+	default:
+		chr = 'e';
+		break;
+	case 'g':
+		/*
+		 * decide on 'e' of 'f' style convers
+		 */
+		if(e >= -4 && e <= prec) {
+			c1 = -e;
+			c4 = prec - e;
+			chr = 'h';	/* flag for 'f' style */
+		}
+		break;
+	case 'f':
+		c1 = -e;
+		if(c1 > prec)
+			c1 = prec + 1;
+		c2 += e;
+		break;
+	}
+
+	/*
+	 * clean up c1 c2 and c3
+	 */
+	if(c1 < 0)
+		c1 = 0;
+	if(c2 < 0)
+		c2 = 0;
+	if(c2 > NSIGNIF) {
+		c3 = c2-NSIGNIF;
+		c2 = NSIGNIF;
+	}
+
+	/*
+	 * trim trailing zeros for %g
+	 */
+	if(!(fl & FmtSharp)
+	&& (chr == 'g' || chr == 'h')){
+		if(c4 >= c3){
+			c4 -= c3;
+			c3 = 0;
+		}else{
+			c3 -= c4;
+			c4 = 0;
+		}
+		while(c4 && c2 > 1 && s1[c2 - 1] == '0'){
+			c4--;
+			c2--;
+		}
+	}
+
+	/*
+	 * calculate the total length
+	 */
+	n = c1 + c2 + c3;
+	if(sign || (fl & (FmtSign|FmtSpace)))
+		n++;
+	if(c4 || (fl & FmtSharp)){
+		n++;
+	}
+	if(chr == 'e' || chr == 'g'){
+		n += 4;
+		if(e >= 100)
+			n++;
+	}
+
+	/*
+	 * pad to width if right justified
+	 */
+	if((fl & (FmtWidth|FmtLeft)) == FmtWidth && n < fmt->width){
+		if(fl & FmtZero){
+			c1 += fmt->width - n;
+		}else{
+			if(__fmtpad(fmt, fmt->width - n) < 0){
+				return -1;
+			}
+		}
+	}
+
+	/*
+	 * sign
+	 */
+	d = 0;
+	if(sign)
+		d = '-';
+	else if(fl & FmtSign)
+		d = '+';
+	else if(fl & FmtSpace)
+		d = ' ';
+	if(d && fmtrune(fmt, d) < 0){
+		return -1;
+	}
+
+	/*
+	 * copy digits
+	 */
+	c4 = c1 + c2 + c3 - c4;
+	if(c1 > 0){
+		if(fmtzdotpad(fmt, c1, c4) < 0){
+			return -1;
+		}
+		c4 -= c1;
+	}
+	d = 0;
+	if(c4 >= 0 && c4 < c2){
+		if(__fmtcpy(fmt, s1, c4, c4) < 0 || fmtrune(fmt, '.') < 0)
+			return -1;
+		d = c4;
+		c2 -= c4;
+		c4 = -1;
+	}
+	if(__fmtcpy(fmt, (const void*)(s1 + d), c2, c2) < 0){
+		return -1;
+	}
+	c4 -= c2;
+	if(c3 > 0){
+		if(fmtzdotpad(fmt, c3, c4) < 0){
+			return -1;
+		}
+		c4 -= c3;
+	}
+
+	/*
+	 * strip trailing '0' on g conv
+	 */
+	if((fl & FmtSharp) && c4 == 0 && fmtrune(fmt, '.') < 0){
+		return -1;
+	}
+	if(chr == 'e' || chr == 'g') {
+		d = 0;
+		if(ucase)
+			s1[d++] = 'E';
+		else
+			s1[d++] = 'e';
+		c1 = e;
+		if(c1 < 0) {
+			s1[d++] = '-';
+			c1 = -c1;
+		} else
+			s1[d++] = '+';
+		if(c1 >= 100) {
+			s1[d++] = c1/100 + '0';
+			c1 = c1%100;
+		}
+		s1[d++] = c1/10 + '0';
+		s1[d++] = c1%10 + '0';
+		if(__fmtcpy(fmt, s1, d, d) < 0){
+			return -1;
+		}
+	}
+	if((fl & (FmtWidth|FmtLeft)) == (FmtWidth|FmtLeft) && n < fmt->width){
+		if(__fmtpad(fmt, fmt->width - n) < 0){
+			return -1;
+		}
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/fmt.c b/sys/src/ape/lib/fmt/fmt.c
new file mode 100755
index 000000000..976bf7ca2
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmt.c
@@ -0,0 +1,221 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+enum
+{
+	Maxfmt = 64
+};
+
+typedef struct Convfmt Convfmt;
+struct Convfmt
+{
+	int	c;
+	volatile	Fmts	fmt;	/* for spin lock in fmtfmt; avoids race due to write order */
+};
+
+struct
+{
+	/* lock by calling __fmtlock, __fmtunlock */
+	int	nfmt;
+	Convfmt	fmt[Maxfmt];
+} fmtalloc;
+
+static Convfmt knownfmt[] = {
+	' ',	__flagfmt,
+	'#',	__flagfmt,
+	'%',	__percentfmt,
+	'+',	__flagfmt,
+	',',	__flagfmt,
+	'-',	__flagfmt,
+	'C',	__runefmt,	/* Plan 9 addition */
+	'E',	__efgfmt,
+	'F',	__efgfmt,	/* ANSI only */
+	'G',	__efgfmt,
+	'L',	__flagfmt,	/* ANSI only */
+	'S',	__runesfmt,	/* Plan 9 addition */
+	'X',	__ifmt,
+	'b',	__ifmt,		/* Plan 9 addition */
+	'c',	__charfmt,
+	'd',	__ifmt,
+	'e',	__efgfmt,
+	'f',	__efgfmt,
+	'g',	__efgfmt,
+	'h',	__flagfmt,
+	'i',	__ifmt,		/* ANSI only */
+	'l',	__flagfmt,
+	'n',	__countfmt,
+	'o',	__ifmt,
+	'p',	__ifmt,
+	'r',	__errfmt,
+	's',	__strfmt,
+	'u',	__flagfmt,	/* in Unix, __ifmt */
+	'x',	__ifmt,
+	0,	nil,
+};
+
+
+int	(*fmtdoquote)(int);
+
+/*
+ * __fmtlock() must be set
+ */
+static int
+__fmtinstall(int c, Fmts f)
+{
+	Convfmt *p, *ep;
+
+	if(c<=0 || c>=65536)
+		return -1;
+	if(!f)
+		f = __badfmt;
+
+	ep = &fmtalloc.fmt[fmtalloc.nfmt];
+	for(p=fmtalloc.fmt; p<ep; p++)
+		if(p->c == c)
+			break;
+
+	if(p == &fmtalloc.fmt[Maxfmt])
+		return -1;
+
+	p->fmt = f;
+	if(p == ep){	/* installing a new format character */
+		fmtalloc.nfmt++;
+		p->c = c;
+	}
+
+	return 0;
+}
+
+int
+fmtinstall(int c, Fmts f)
+{
+	int ret;
+
+	__fmtlock();
+	ret = __fmtinstall(c, f);
+	__fmtunlock();
+	return ret;
+}
+
+static Fmts
+fmtfmt(int c)
+{
+	Convfmt *p, *ep;
+
+	ep = &fmtalloc.fmt[fmtalloc.nfmt];
+	for(p=fmtalloc.fmt; p<ep; p++)
+		if(p->c == c){
+			while(p->fmt == nil)	/* loop until value is updated */
+				;
+			return p->fmt;
+		}
+
+	/* is this a predefined format char? */
+	__fmtlock();
+	for(p=knownfmt; p->c; p++)
+		if(p->c == c){
+			__fmtinstall(p->c, p->fmt);
+			__fmtunlock();
+			return p->fmt;
+		}
+	__fmtunlock();
+
+	return __badfmt;
+}
+
+void*
+__fmtdispatch(Fmt *f, void *fmt, int isrunes)
+{
+	Rune rune, r;
+	int i, n;
+
+	f->flags = 0;
+	f->width = f->prec = 0;
+
+	for(;;){
+		if(isrunes){
+			r = *(Rune*)fmt;
+			fmt = (Rune*)fmt + 1;
+		}else{
+			fmt = (char*)fmt + chartorune(&rune, (char*)fmt);
+			r = rune;
+		}
+		f->r = r;
+		switch(r){
+		case '\0':
+			return nil;
+		case '.':
+			f->flags |= FmtWidth|FmtPrec;
+			continue;
+		case '0':
+			if(!(f->flags & FmtWidth)){
+				f->flags |= FmtZero;
+				continue;
+			}
+			/* fall through */
+		case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+			i = 0;
+			while(r >= '0' && r <= '9'){
+				i = i * 10 + r - '0';
+				if(isrunes){
+					r = *(Rune*)fmt;
+					fmt = (Rune*)fmt + 1;
+				}else{
+					r = *(char*)fmt;
+					fmt = (char*)fmt + 1;
+				}
+			}
+			if(isrunes)
+				fmt = (Rune*)fmt - 1;
+			else
+				fmt = (char*)fmt - 1;
+		numflag:
+			if(f->flags & FmtWidth){
+				f->flags |= FmtPrec;
+				f->prec = i;
+			}else{
+				f->flags |= FmtWidth;
+				f->width = i;
+			}
+			continue;
+		case '*':
+			i = va_arg(f->args, int);
+			if(i < 0){
+				/*
+				 * negative precision =>
+				 * ignore the precision.
+				 */
+				if(f->flags & FmtPrec){
+					f->flags &= ~FmtPrec;
+					f->prec = 0;
+					continue;
+				}
+				i = -i;
+				f->flags |= FmtLeft;
+			}
+			goto numflag;
+		}
+		n = (*fmtfmt(r))(f);
+		if(n < 0)
+			return nil;
+		if(n == 0)
+			return fmt;
+	}
+}
diff --git a/sys/src/ape/lib/fmt/fmtdef.h b/sys/src/ape/lib/fmt/fmtdef.h
new file mode 100755
index 000000000..797c724d2
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtdef.h
@@ -0,0 +1,121 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+/*
+ * dofmt -- format to a buffer
+ * the number of characters formatted is returned,
+ * or -1 if there was an error.
+ * if the buffer is ever filled, flush is called.
+ * it should reset the buffer and return whether formatting should continue.
+ */
+#define uchar _fmtuchar
+#define ushort _fmtushort
+#define uint _fmtuint
+#define ulong _fmtulong
+#define vlong _fmtvlong
+#define uvlong _fmtuvlong
+
+#define USED(x) if(x);else
+
+typedef unsigned char		uchar;
+typedef unsigned short		ushort;
+typedef unsigned int		uint;
+typedef unsigned long		ulong;
+
+#ifndef NOVLONGS
+typedef unsigned long long	uvlong;
+typedef long long		vlong;
+#endif
+
+/* #define nil		0	/* cannot be ((void*)0) because used for function pointers */
+
+typedef int (*Fmts)(Fmt*);
+
+typedef struct Quoteinfo Quoteinfo;
+struct Quoteinfo
+{
+	int	quoted;		/* if set, string must be quoted */
+	int	nrunesin;	/* number of input runes that can be accepted */
+	int	nbytesin;	/* number of input bytes that can be accepted */
+	int	nrunesout;	/* number of runes that will be generated */
+	int	nbytesout;	/* number of bytes that will be generated */
+};
+
+void	*__fmtflush(Fmt*, void*, int);
+void	*__fmtdispatch(Fmt*, void*, int);
+int	__floatfmt(Fmt*, double);
+int	__fmtpad(Fmt*, int);
+int	__rfmtpad(Fmt*, int);
+int	__fmtFdFlush(Fmt*);
+
+int	__efgfmt(Fmt*);
+int	__charfmt(Fmt*);
+int	__runefmt(Fmt*);
+int	__runesfmt(Fmt*);
+int	__countfmt(Fmt*);
+int	__flagfmt(Fmt*);
+int	__percentfmt(Fmt*);
+int	__ifmt(Fmt*);
+int	__strfmt(Fmt*);
+int	__badfmt(Fmt*);
+int	__fmtcpy(Fmt*, const void*, int, int);
+int	__fmtrcpy(Fmt*, const void*, int n);
+int	__errfmt(Fmt *f);
+
+double	__fmtpow10(int);
+
+void	__fmtlock(void);
+void	__fmtunlock(void);
+
+#define FMTCHAR(f, t, s, c)\
+	do{\
+	if(t + 1 > (char*)s){\
+		t = __fmtflush(f, t, 1);\
+		if(t != nil)\
+			s = f->stop;\
+		else\
+			return -1;\
+	}\
+	*t++ = c;\
+	}while(0)
+
+#define FMTRCHAR(f, t, s, c)\
+	do{\
+	if(t + 1 > (Rune*)s){\
+		t = __fmtflush(f, t, sizeof(Rune));\
+		if(t != nil)\
+			s = f->stop;\
+		else\
+			return -1;\
+	}\
+	*t++ = c;\
+	}while(0)
+
+#define FMTRUNE(f, t, s, r)\
+	do{\
+	Rune _rune;\
+	int _runelen;\
+	if(t + UTFmax > (char*)s && t + (_runelen = runelen(r)) > (char*)s){\
+		t = __fmtflush(f, t, _runelen);\
+		if(t != nil)\
+			s = f->stop;\
+		else\
+			return -1;\
+	}\
+	if(r < Runeself)\
+		*t++ = r;\
+	else{\
+		_rune = r;\
+		t += runetochar(t, &_rune);\
+	}\
+	}while(0)
diff --git a/sys/src/ape/lib/fmt/fmtfd.c b/sys/src/ape/lib/fmt/fmtfd.c
new file mode 100755
index 000000000..d4251402a
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtfd.c
@@ -0,0 +1,46 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * public routine for final flush of a formatting buffer
+ * to a file descriptor; returns total char count.
+ */
+int
+fmtfdflush(Fmt *f)
+{
+	if(__fmtFdFlush(f) <= 0)
+		return -1;
+	return f->nfmt;
+}
+
+/*
+ * initialize an output buffer for buffered printing
+ */
+int
+fmtfdinit(Fmt *f, int fd, char *buf, int size)
+{
+	f->runes = 0;
+	f->start = buf;
+	f->to = buf;
+	f->stop = buf + size;
+	f->flush = __fmtFdFlush;
+	f->farg = (void*)fd;
+	f->nfmt = 0;
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/fmtfdflush.c b/sys/src/ape/lib/fmt/fmtfdflush.c
new file mode 100755
index 000000000..796feab23
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtfdflush.c
@@ -0,0 +1,33 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <unistd.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * generic routine for flushing a formatting buffer
+ * to a file descriptor
+ */
+int
+__fmtFdFlush(Fmt *f)
+{
+	int n;
+
+	n = (char*)f->to - (char*)f->start;
+	if(n && write((int)f->farg, f->start, n) != n)
+		return 0;
+	f->to = f->start;
+	return 1;
+}
diff --git a/sys/src/ape/lib/fmt/fmtlock.c b/sys/src/ape/lib/fmt/fmtlock.c
new file mode 100755
index 000000000..fffe81cfc
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtlock.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+void
+__fmtlock(void)
+{
+	;
+}
+
+void
+__fmtunlock(void)
+{
+	;
+}
diff --git a/sys/src/ape/lib/fmt/fmtprint.c b/sys/src/ape/lib/fmt/fmtprint.c
new file mode 100755
index 000000000..fe2ad3cc8
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtprint.c
@@ -0,0 +1,47 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+
+/*
+ * format a string into the output buffer
+ * designed for formats which themselves call fmt,
+ * but ignore any width flags
+ */
+int
+fmtprint(Fmt *f, char *fmt, ...)
+{
+	va_list va;
+	int n;
+
+	f->flags = 0;
+	f->width = 0;
+	f->prec = 0;
+	va = f->args;
+	va_start(f->args, fmt);
+	n = dofmt(f, fmt);
+	va_end(f->args);
+	f->flags = 0;
+	f->width = 0;
+	f->prec = 0;
+	f->args = va;
+	if(n >= 0)
+		return 0;
+	return n;
+}
+
diff --git a/sys/src/ape/lib/fmt/fmtquote.c b/sys/src/ape/lib/fmt/fmtquote.c
new file mode 100755
index 000000000..9d5633d6c
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtquote.c
@@ -0,0 +1,262 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * How many bytes of output UTF will be produced by quoting (if necessary) this string?
+ * How many runes? How much of the input will be consumed?
+ * The parameter q is filled in by __quotesetup.
+ * The string may be UTF or Runes (s or r).
+ * Return count does not include NUL.
+ * Terminate the scan at the first of:
+ *	NUL in input
+ *	count exceeded in input
+ *	count exceeded on output
+ * *ninp is set to number of input bytes accepted.
+ * nin may be <0 initially, to avoid checking input by count.
+ */
+void
+__quotesetup(char *s, Rune *r, int nin, int nout, Quoteinfo *q, int sharp, int runesout)
+{
+	int w;
+	Rune c;
+
+	q->quoted = 0;
+	q->nbytesout = 0;
+	q->nrunesout = 0;
+	q->nbytesin = 0;
+	q->nrunesin = 0;
+	if(sharp || nin==0 || (s && *s=='\0') || (r && *r=='\0')){
+		if(nout < 2)
+			return;
+		q->quoted = 1;
+		q->nbytesout = 2;
+		q->nrunesout = 2;
+	}
+	for(; nin!=0; nin-=w){
+		if(s)
+			w = chartorune(&c, s);
+		else{
+			c = *r;
+			w = runelen(c);
+		}
+
+		if(c == '\0')
+			break;
+		if(runesout){
+			if(q->nrunesout+1 > nout)
+				break;
+		}else{
+			if(q->nbytesout+w > nout)
+				break;
+		}
+
+		if((c <= L' ') || (c == L'\'') || (fmtdoquote!=nil && fmtdoquote(c))){
+			if(!q->quoted){
+				if(runesout){
+					if(1+q->nrunesout+1+1 > nout)	/* no room for quotes */
+						break;
+				}else{
+					if(1+q->nbytesout+w+1 > nout)	/* no room for quotes */
+						break;
+				}
+				q->nrunesout += 2;	/* include quotes */
+				q->nbytesout += 2;	/* include quotes */
+				q->quoted = 1;
+			}
+			if(c == '\'')	{
+				if(runesout){
+					if(1+q->nrunesout+1 > nout)	/* no room for quotes */
+						break;
+				}else{
+					if(1+q->nbytesout+w > nout)	/* no room for quotes */
+						break;
+				}
+				q->nbytesout++;
+				q->nrunesout++;	/* quotes reproduce as two characters */
+			}
+		}
+
+		/* advance input */
+		if(s)
+			s += w;
+		else
+			r++;
+		q->nbytesin += w;
+		q->nrunesin++;
+
+		/* advance output */
+		q->nbytesout += w;
+		q->nrunesout++;
+	}
+}
+
+static int
+qstrfmt(char *sin, Rune *rin, Quoteinfo *q, Fmt *f)
+{
+	Rune r, *rm, *rme;
+	char *t, *s, *m, *me;
+	Rune *rt, *rs;
+	ulong fl;
+	int nc, w;
+
+	m = sin;
+	me = m + q->nbytesin;
+	rm = rin;
+	rme = rm + q->nrunesin;
+
+	w = f->width;
+	fl = f->flags;
+	if(f->runes){
+		if(!(fl & FmtLeft) && __rfmtpad(f, w - q->nrunesout) < 0)
+			return -1;
+	}else{
+		if(!(fl & FmtLeft) && __fmtpad(f, w - q->nbytesout) < 0)
+			return -1;
+	}
+	t = (char*)f->to;
+	s = (char*)f->stop;
+	rt = (Rune*)f->to;
+	rs = (Rune*)f->stop;
+	if(f->runes)
+		FMTRCHAR(f, rt, rs, '\'');
+	else
+		FMTRUNE(f, t, s, '\'');
+	for(nc = q->nrunesin; nc > 0; nc--){
+		if(sin){
+			r = *(uchar*)m;
+			if(r < Runeself)
+				m++;
+			else if((me - m) >= UTFmax || fullrune(m, me-m))
+				m += chartorune(&r, m);
+			else
+				break;
+		}else{
+			if(rm >= rme)
+				break;
+			r = *(uchar*)rm++;
+		}
+		if(f->runes){
+			FMTRCHAR(f, rt, rs, r);
+			if(r == '\'')
+				FMTRCHAR(f, rt, rs, r);
+		}else{
+			FMTRUNE(f, t, s, r);
+			if(r == '\'')
+				FMTRUNE(f, t, s, r);
+		}
+	}
+
+	if(f->runes){
+		FMTRCHAR(f, rt, rs, '\'');
+		USED(rs);
+		f->nfmt += rt - (Rune *)f->to;
+		f->to = rt;
+		if(fl & FmtLeft && __rfmtpad(f, w - q->nrunesout) < 0)
+			return -1;
+	}else{
+		FMTRUNE(f, t, s, '\'');
+		USED(s);
+		f->nfmt += t - (char *)f->to;
+		f->to = t;
+		if(fl & FmtLeft && __fmtpad(f, w - q->nbytesout) < 0)
+			return -1;
+	}
+	return 0;
+}
+
+int
+__quotestrfmt(int runesin, Fmt *f)
+{
+	int outlen;
+	Rune *r;
+	char *s;
+	Quoteinfo q;
+
+	f->flags &= ~FmtPrec;	/* ignored for %q %Q, so disable for %s %S in easy case */
+	if(runesin){
+		r = va_arg(f->args, Rune *);
+		s = nil;
+	}else{
+		s = va_arg(f->args, char *);
+		r = nil;
+	}
+	if(!s && !r)
+		return __fmtcpy(f, (void*)"<nil>", 5, 5);
+
+	if(f->flush)
+		outlen = 0x7FFFFFFF;	/* if we can flush, no output limit */
+	else if(f->runes)
+		outlen = (Rune*)f->stop - (Rune*)f->to;
+	else
+		outlen = (char*)f->stop - (char*)f->to;
+
+	__quotesetup(s, r, -1, outlen, &q, f->flags&FmtSharp, f->runes);
+//print("bytes in %d bytes out %d runes in %d runesout %d\n", q.nbytesin, q.nbytesout, q.nrunesin, q.nrunesout);
+
+	if(runesin){
+		if(!q.quoted)
+			return __fmtrcpy(f, r, q.nrunesin);
+		return qstrfmt(nil, r, &q, f);
+	}
+
+	if(!q.quoted)
+		return __fmtcpy(f, s, q.nrunesin, q.nbytesin);
+	return qstrfmt(s, nil, &q, f);
+}
+
+int
+quotestrfmt(Fmt *f)
+{
+	return __quotestrfmt(0, f);
+}
+
+int
+quoterunestrfmt(Fmt *f)
+{
+	return __quotestrfmt(1, f);
+}
+
+void
+quotefmtinstall(void)
+{
+	fmtinstall('q', quotestrfmt);
+	fmtinstall('Q', quoterunestrfmt);
+}
+
+int
+__needsquotes(char *s, int *quotelenp)
+{
+	Quoteinfo q;
+
+	__quotesetup(s, nil, -1, 0x7FFFFFFF, &q, 0, 0);
+	*quotelenp = q.nbytesout;
+
+	return q.quoted;
+}
+
+int
+__runeneedsquotes(Rune *r, int *quotelenp)
+{
+	Quoteinfo q;
+
+	__quotesetup(nil, r, -1, 0x7FFFFFFF, &q, 0, 0);
+	*quotelenp = q.nrunesout;
+
+	return q.quoted;
+}
diff --git a/sys/src/ape/lib/fmt/fmtrune.c b/sys/src/ape/lib/fmt/fmtrune.c
new file mode 100755
index 000000000..a034546bc
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtrune.c
@@ -0,0 +1,40 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+fmtrune(Fmt *f, int r)
+{
+	Rune *rt;
+	char *t;
+	int n;
+
+	if(f->runes){
+		rt = (Rune*)f->to;
+		FMTRCHAR(f, rt, f->stop, r);
+		f->to = rt;
+		n = 1;
+	}else{
+		t = (char*)f->to;
+		FMTRUNE(f, t, f->stop, r);
+		n = t - (char*)f->to;
+		f->to = t;
+	}
+	f->nfmt += n;
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/fmtstr.c b/sys/src/ape/lib/fmt/fmtstr.c
new file mode 100755
index 000000000..7af1fa241
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtstr.c
@@ -0,0 +1,65 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+static int
+fmtStrFlush(Fmt *f)
+{
+	char *s;
+	int n;
+
+	n = (int)f->farg;
+	n += 256;
+	f->farg = (void*)n;
+	s = (char*)f->start;
+	f->start = realloc(s, n);
+	if(f->start == nil){
+		f->start = s;
+		return 0;
+	}
+	f->to = (char*)f->start + ((char*)f->to - s);
+	f->stop = (char*)f->start + n - 1;
+	return 1;
+}
+
+int
+fmtstrinit(Fmt *f)
+{
+	int n;
+
+	f->runes = 0;
+	n = 32;
+	f->start = malloc(n);
+	if(f->start == nil)
+		return -1;
+	f->to = f->start;
+	f->stop = (char*)f->start + n - 1;
+	f->flush = fmtStrFlush;
+	f->farg = (void*)n;
+	f->nfmt = 0;
+	return 0;
+}
+
+char*
+fmtstrflush(Fmt *f)
+{
+	*(char*)f->to = '\0';
+	f->to = f->start;
+	return (char*)f->start;
+}
diff --git a/sys/src/ape/lib/fmt/fmtvprint.c b/sys/src/ape/lib/fmt/fmtvprint.c
new file mode 100755
index 000000000..6aed013d9
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fmtvprint.c
@@ -0,0 +1,46 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+
+/*
+ * format a string into the output buffer
+ * designed for formats which themselves call fmt,
+ * but ignore any width flags
+ */
+int
+fmtvprint(Fmt *f, char *fmt, va_list args)
+{
+	va_list va;
+	int n;
+
+	f->flags = 0;
+	f->width = 0;
+	f->prec = 0;
+	va = f->args;
+	f->args = args;
+	n = dofmt(f, fmt);
+	f->flags = 0;
+	f->width = 0;
+	f->prec = 0;
+	f->args = va;
+	if(n >= 0)
+		return 0;
+	return n;
+}
+
diff --git a/sys/src/ape/lib/fmt/fprint.c b/sys/src/ape/lib/fmt/fprint.c
new file mode 100755
index 000000000..c8b889de6
--- /dev/null
+++ b/sys/src/ape/lib/fmt/fprint.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "utf.h"
+#include "fmt.h"
+
+int
+fprint(int fd, char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = vfprint(fd, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/fmt/mkfile b/sys/src/ape/lib/fmt/mkfile
new file mode 100755
index 000000000..5644f2a45
--- /dev/null
+++ b/sys/src/ape/lib/fmt/mkfile
@@ -0,0 +1,59 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libfmt.a
+
+NUM=\
+	charstod.$O\
+	pow10.$O\
+
+OFILES=\
+	dofmt.$O\
+	errfmt.$O\
+	fltfmt.$O\
+	fmt.$O\
+	fmtfd.$O\
+	fmtfdflush.$O\
+	fmtlock.$O\
+	fmtprint.$O\
+	fmtquote.$O\
+	fmtrune.$O\
+	fmtstr.$O\
+	fmtvprint.$O\
+	fprint.$O\
+	nan64.$O\
+	print.$O\
+	runefmtstr.$O\
+	runeseprint.$O\
+	runesmprint.$O\
+	runesnprint.$O\
+	runesprint.$O\
+	runevseprint.$O\
+	runevsmprint.$O\
+	runevsnprint.$O\
+	seprint.$O\
+	smprint.$O\
+	snprint.$O\
+	sprint.$O\
+	strtod.$O\
+	vfprint.$O\
+	vseprint.$O\
+	vsmprint.$O\
+	vsnprint.$O\
+	werrstr.$O\
+	$NUM\
+
+HFILES=\
+	fmtdef.h\
+	/sys/include/ape/fmt.h\
+
+</sys/src/cmd/mksyslib
+
+$NAN.$O: nan.h
+strtod.$O: nan.h
+
+test: $LIB test.$O
+	$CC -o test test.$O $LIB -L$PLAN9/lib -lutf
+
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE -D_BSD_EXTENSION
diff --git a/sys/src/ape/lib/fmt/nan.h b/sys/src/ape/lib/fmt/nan.h
new file mode 100755
index 000000000..be78e14e5
--- /dev/null
+++ b/sys/src/ape/lib/fmt/nan.h
@@ -0,0 +1,4 @@
+extern double __NaN(void);
+extern double __Inf(int);
+extern int __isNaN(double);
+extern int __isInf(double, int);
diff --git a/sys/src/ape/lib/fmt/nan64.c b/sys/src/ape/lib/fmt/nan64.c
new file mode 100755
index 000000000..a02a3adb6
--- /dev/null
+++ b/sys/src/ape/lib/fmt/nan64.c
@@ -0,0 +1,76 @@
+/*
+ * 64-bit IEEE not-a-number routines.
+ * This is big/little-endian portable assuming that 
+ * the 64-bit doubles and 64-bit integers have the
+ * same byte ordering.
+ */
+
+#include "nan.h"
+
+#ifdef __APPLE__
+#define _NEEDLL
+#endif
+
+typedef unsigned long long uvlong;
+typedef unsigned long ulong;
+
+#ifdef _NEEDLL
+static uvlong uvnan    = 0x7FF0000000000001LL;
+static uvlong uvinf    = 0x7FF0000000000000LL;
+static uvlong uvneginf = 0xFFF0000000000000LL;
+#else
+static uvlong uvnan    = 0x7FF0000000000001;
+static uvlong uvinf    = 0x7FF0000000000000;
+static uvlong uvneginf = 0xFFF0000000000000;
+#endif
+
+double
+__NaN(void)
+{
+	uvlong *p;
+
+	/* gcc complains about "return *(double*)&uvnan;" */
+	p = &uvnan;
+	return *(double*)p;
+}
+
+int
+__isNaN(double d)
+{
+	uvlong x;
+	double *p;
+
+	p = &d;
+	x = *(uvlong*)p;
+	return (ulong)(x>>32)==0x7FF00000 && !__isInf(d, 0);
+}
+
+double
+__Inf(int sign)
+{
+	uvlong *p;
+
+	if(sign < 0)
+		p = &uvinf;
+	else
+		p = &uvneginf;
+	return *(double*)p;
+}
+
+int
+__isInf(double d, int sign)
+{
+	uvlong x;
+	double *p;
+
+	p = &d;
+	x = *(uvlong*)p;
+	if(sign == 0)
+		return x==uvinf || x==uvneginf;
+	else if(sign > 0)
+		return x==uvinf;
+	else
+		return x==uvneginf;
+}
+
+
diff --git a/sys/src/ape/lib/fmt/pow10.c b/sys/src/ape/lib/fmt/pow10.c
new file mode 100755
index 000000000..65a426c30
--- /dev/null
+++ b/sys/src/ape/lib/fmt/pow10.c
@@ -0,0 +1,57 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * this table might overflow 127-bit exponent representations.
+ * in that case, truncate it after 1.0e38.
+ * it is important to get all one can from this
+ * routine since it is used in atof to scale numbers.
+ * the presumption is that C converts fp numbers better
+ * than multipication of lower powers of 10.
+ */
+
+static
+double	tab[] =
+{
+	1.0e0, 1.0e1, 1.0e2, 1.0e3, 1.0e4, 1.0e5, 1.0e6, 1.0e7, 1.0e8, 1.0e9,
+	1.0e10,1.0e11,1.0e12,1.0e13,1.0e14,1.0e15,1.0e16,1.0e17,1.0e18,1.0e19,
+	1.0e20,1.0e21,1.0e22,1.0e23,1.0e24,1.0e25,1.0e26,1.0e27,1.0e28,1.0e29,
+	1.0e30,1.0e31,1.0e32,1.0e33,1.0e34,1.0e35,1.0e36,1.0e37,1.0e38,1.0e39,
+	1.0e40,1.0e41,1.0e42,1.0e43,1.0e44,1.0e45,1.0e46,1.0e47,1.0e48,1.0e49,
+	1.0e50,1.0e51,1.0e52,1.0e53,1.0e54,1.0e55,1.0e56,1.0e57,1.0e58,1.0e59,
+	1.0e60,1.0e61,1.0e62,1.0e63,1.0e64,1.0e65,1.0e66,1.0e67,1.0e68,1.0e69,
+};
+
+double
+__fmtpow10(int n)
+{
+	int m;
+
+	if(n < 0) {
+		n = -n;
+		if(n < (int)(sizeof(tab)/sizeof(tab[0])))
+			return 1/tab[n];
+		m = n/2;
+		return __fmtpow10(-m) * __fmtpow10(m-n);
+	}
+	if(n < (int)(sizeof(tab)/sizeof(tab[0])))
+		return tab[n];
+	m = n/2;
+	return __fmtpow10(m) * __fmtpow10(n-m);
+}
diff --git a/sys/src/ape/lib/fmt/print.c b/sys/src/ape/lib/fmt/print.c
new file mode 100755
index 000000000..381a1da92
--- /dev/null
+++ b/sys/src/ape/lib/fmt/print.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "utf.h"
+#include "fmt.h"
+
+int
+print(char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = vfprint(1, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/fmt/runefmtstr.c b/sys/src/ape/lib/fmt/runefmtstr.c
new file mode 100755
index 000000000..a2ec6cb48
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runefmtstr.c
@@ -0,0 +1,65 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+static int
+runeFmtStrFlush(Fmt *f)
+{
+	Rune *s;
+	int n;
+
+	n = (int)f->farg;
+	n += 256;
+	f->farg = (void*)n;
+	s = (Rune*)f->start;
+	f->start = realloc(s, sizeof(Rune)*n);
+	if(f->start == nil){
+		f->start = s;
+		return 0;
+	}
+	f->to = (Rune*)f->start + ((Rune*)f->to - s);
+	f->stop = (Rune*)f->start + n - 1;
+	return 1;
+}
+
+int
+runefmtstrinit(Fmt *f)
+{
+	int n;
+
+	f->runes = 1;
+	n = 32;
+	f->start = malloc(sizeof(Rune)*n);
+	if(f->start == nil)
+		return -1;
+	f->to = f->start;
+	f->stop = (Rune*)f->start + n - 1;
+	f->flush = runeFmtStrFlush;
+	f->farg = (void*)n;
+	f->nfmt = 0;
+	return 0;
+}
+
+Rune*
+runefmtstrflush(Fmt *f)
+{
+	*(Rune*)f->to = '\0';
+	f->to = f->start;
+	return f->start;
+}
diff --git a/sys/src/ape/lib/fmt/runeseprint.c b/sys/src/ape/lib/fmt/runeseprint.c
new file mode 100755
index 000000000..7829a4399
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runeseprint.c
@@ -0,0 +1,30 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+Rune*
+runeseprint(Rune *buf, Rune *e, char *fmt, ...)
+{
+	Rune *p;
+	va_list args;
+
+	va_start(args, fmt);
+	p = runevseprint(buf, e, fmt, args);
+	va_end(args);
+	return p;
+}
diff --git a/sys/src/ape/lib/fmt/runesmprint.c b/sys/src/ape/lib/fmt/runesmprint.c
new file mode 100755
index 000000000..538ae0ee3
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runesmprint.c
@@ -0,0 +1,30 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+Rune*
+runesmprint(char *fmt, ...)
+{
+	va_list args;
+	Rune *p;
+
+	va_start(args, fmt);
+	p = runevsmprint(fmt, args);
+	va_end(args);
+	return p;
+}
diff --git a/sys/src/ape/lib/fmt/runesnprint.c b/sys/src/ape/lib/fmt/runesnprint.c
new file mode 100755
index 000000000..5abb6dbf1
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runesnprint.c
@@ -0,0 +1,31 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+runesnprint(Rune *buf, int len, char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = runevsnprint(buf, len, fmt, args);
+	va_end(args);
+	return n;
+}
+
diff --git a/sys/src/ape/lib/fmt/runesprint.c b/sys/src/ape/lib/fmt/runesprint.c
new file mode 100755
index 000000000..8abfeb658
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runesprint.c
@@ -0,0 +1,30 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+runesprint(Rune *buf, char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = runevsnprint(buf, 256, fmt, args);
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/fmt/runevseprint.c b/sys/src/ape/lib/fmt/runevseprint.c
new file mode 100755
index 000000000..e4cc1ea87
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runevseprint.c
@@ -0,0 +1,39 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+Rune*
+runevseprint(Rune *buf, Rune *e, char *fmt, va_list args)
+{
+	Fmt f;
+
+	if(e <= buf)
+		return nil;
+	f.runes = 1;
+	f.start = buf;
+	f.to = buf;
+	f.stop = e - 1;
+	f.flush = nil;
+	f.farg = nil;
+	f.nfmt = 0;
+	f.args = args;
+	dofmt(&f, fmt);
+	*(Rune*)f.to = '\0';
+	return (Rune*)f.to;
+}
+
diff --git a/sys/src/ape/lib/fmt/runevsmprint.c b/sys/src/ape/lib/fmt/runevsmprint.c
new file mode 100755
index 000000000..71c23d844
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runevsmprint.c
@@ -0,0 +1,37 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * print into an allocated string buffer
+ */
+Rune*
+runevsmprint(char *fmt, va_list args)
+{
+	Fmt f;
+	int n;
+
+	if(runefmtstrinit(&f) < 0)
+		return nil;
+	f.args = args;
+	n = dofmt(&f, fmt);
+	if(n < 0)
+		return nil;
+	*(Rune*)f.to = '\0';
+	return (Rune*)f.start;
+}
diff --git a/sys/src/ape/lib/fmt/runevsnprint.c b/sys/src/ape/lib/fmt/runevsnprint.c
new file mode 100755
index 000000000..933a04ca9
--- /dev/null
+++ b/sys/src/ape/lib/fmt/runevsnprint.c
@@ -0,0 +1,38 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+runevsnprint(Rune *buf, int len, char *fmt, va_list args)
+{
+	Fmt f;
+
+	if(len <= 0)
+		return -1;
+	f.runes = 1;
+	f.start = buf;
+	f.to = buf;
+	f.stop = buf + len - 1;
+	f.flush = nil;
+	f.farg = nil;
+	f.nfmt = 0;
+	f.args = args;
+	dofmt(&f, fmt);
+	*(Rune*)f.to = '\0';
+	return (Rune*)f.to - buf;
+}
diff --git a/sys/src/ape/lib/fmt/seprint.c b/sys/src/ape/lib/fmt/seprint.c
new file mode 100755
index 000000000..d5031a2b1
--- /dev/null
+++ b/sys/src/ape/lib/fmt/seprint.c
@@ -0,0 +1,27 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+
+char*
+seprint(char *buf, char *e, char *fmt, ...)
+{
+	char *p;
+	va_list args;
+
+	va_start(args, fmt);
+	p = vseprint(buf, e, fmt, args);
+	va_end(args);
+	return p;
+}
diff --git a/sys/src/ape/lib/fmt/smprint.c b/sys/src/ape/lib/fmt/smprint.c
new file mode 100755
index 000000000..543411a0a
--- /dev/null
+++ b/sys/src/ape/lib/fmt/smprint.c
@@ -0,0 +1,27 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+
+char*
+smprint(char *fmt, ...)
+{
+	va_list args;
+	char *p;
+
+	va_start(args, fmt);
+	p = vsmprint(fmt, args);
+	va_end(args);
+	return p;
+}
diff --git a/sys/src/ape/lib/fmt/snprint.c b/sys/src/ape/lib/fmt/snprint.c
new file mode 100755
index 000000000..594606d21
--- /dev/null
+++ b/sys/src/ape/lib/fmt/snprint.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+
+int
+snprint(char *buf, int len, char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = vsnprint(buf, len, fmt, args);
+	va_end(args);
+	return n;
+}
+
diff --git a/sys/src/ape/lib/fmt/sprint.c b/sys/src/ape/lib/fmt/sprint.c
new file mode 100755
index 000000000..57150c36b
--- /dev/null
+++ b/sys/src/ape/lib/fmt/sprint.c
@@ -0,0 +1,27 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+
+int
+sprint(char *buf, char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = vsnprint(buf, 65536, fmt, args);	/* big number, but sprint is deprecated anyway */
+	va_end(args);
+	return n;
+}
diff --git a/sys/src/ape/lib/fmt/strtod.c b/sys/src/ape/lib/fmt/strtod.c
new file mode 100755
index 000000000..e24e2a8aa
--- /dev/null
+++ b/sys/src/ape/lib/fmt/strtod.c
@@ -0,0 +1,538 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdlib.h>
+#include <math.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "fmt.h"
+#include "nan.h"
+
+#ifndef nelem
+#define nelem(x)	(sizeof(x)/sizeof *(x))
+#endif
+#define nil ((void*)0)
+#define ulong _fmtulong
+typedef unsigned long ulong;
+
+static ulong
+umuldiv(ulong a, ulong b, ulong c)
+{
+	double d;
+
+	d = ((double)a * (double)b) / (double)c;
+	if(d >= 4294967295.)
+		d = 4294967295.;
+	return (ulong)d;
+}
+
+/*
+ * This routine will convert to arbitrary precision
+ * floating point entirely in multi-precision fixed.
+ * The answer is the closest floating point number to
+ * the given decimal number. Exactly half way are
+ * rounded ala ieee rules.
+ * Method is to scale input decimal between .500 and .999...
+ * with external power of 2, then binary search for the
+ * closest mantissa to this decimal number.
+ * Nmant is is the required precision. (53 for ieee dp)
+ * Nbits is the max number of bits/word. (must be <= 28)
+ * Prec is calculated - the number of words of fixed mantissa.
+ */
+enum
+{
+	Nbits	= 28,				/* bits safely represented in a ulong */
+	Nmant	= 53,				/* bits of precision required */
+	Prec	= (Nmant+Nbits+1)/Nbits,	/* words of Nbits each to represent mantissa */
+	Sigbit	= 1<<(Prec*Nbits-Nmant),	/* first significant bit of Prec-th word */
+	Ndig	= 1500,
+	One	= (ulong)(1<<Nbits),
+	Half	= (ulong)(One>>1),
+	Maxe	= 310,
+
+	Fsign	= 1<<0,		/* found - */
+	Fesign	= 1<<1,		/* found e- */
+	Fdpoint	= 1<<2,		/* found . */
+
+	S0	= 0,		/* _		_S0	+S1	#S2	.S3 */
+	S1,			/* _+		#S2	.S3 */
+	S2,			/* _+#		#S2	.S4	eS5 */
+	S3,			/* _+.		#S4 */
+	S4,			/* _+#.#	#S4	eS5 */
+	S5,			/* _+#.#e	+S6	#S7 */
+	S6,			/* _+#.#e+	#S7 */
+	S7,			/* _+#.#e+#	#S7 */
+};
+
+static	int	xcmp(char*, char*);
+static	int	fpcmp(char*, ulong*);
+static	void	frnorm(ulong*);
+static	void	divascii(char*, int*, int*, int*);
+static	void	mulascii(char*, int*, int*, int*);
+
+typedef	struct	Tab	Tab;
+struct	Tab
+{
+	int	bp;
+	int	siz;
+	char*	cmp;
+};
+
+double
+fmtstrtod(const char *as, char **aas)
+{
+	int na, ex, dp, bp, c, i, flag, state;
+	ulong low[Prec], hig[Prec], mid[Prec];
+	double d;
+	char *s, a[Ndig];
+
+	flag = 0;	/* Fsign, Fesign, Fdpoint */
+	na = 0;		/* number of digits of a[] */
+	dp = 0;		/* na of decimal point */
+	ex = 0;		/* exonent */
+
+	state = S0;
+	for(s=(char*)as;; s++) {
+		c = *s;
+		if(c >= '0' && c <= '9') {
+			switch(state) {
+			case S0:
+			case S1:
+			case S2:
+				state = S2;
+				break;
+			case S3:
+			case S4:
+				state = S4;
+				break;
+
+			case S5:
+			case S6:
+			case S7:
+				state = S7;
+				ex = ex*10 + (c-'0');
+				continue;
+			}
+			if(na == 0 && c == '0') {
+				dp--;
+				continue;
+			}
+			if(na < Ndig-50)
+				a[na++] = c;
+			continue;
+		}
+		switch(c) {
+		case '\t':
+		case '\n':
+		case '\v':
+		case '\f':
+		case '\r':
+		case ' ':
+			if(state == S0)
+				continue;
+			break;
+		case '-':
+			if(state == S0)
+				flag |= Fsign;
+			else
+				flag |= Fesign;
+		case '+':
+			if(state == S0)
+				state = S1;
+			else
+			if(state == S5)
+				state = S6;
+			else
+				break;	/* syntax */
+			continue;
+		case '.':
+			flag |= Fdpoint;
+			dp = na;
+			if(state == S0 || state == S1) {
+				state = S3;
+				continue;
+			}
+			if(state == S2) {
+				state = S4;
+				continue;
+			}
+			break;
+		case 'e':
+		case 'E':
+			if(state == S2 || state == S4) {
+				state = S5;
+				continue;
+			}
+			break;
+		}
+		break;
+	}
+
+	/*
+	 * clean up return char-pointer
+	 */
+	switch(state) {
+	case S0:
+		if(xcmp(s, "nan") == 0) {
+			if(aas != nil)
+				*aas = s+3;
+			goto retnan;
+		}
+	case S1:
+		if(xcmp(s, "infinity") == 0) {
+			if(aas != nil)
+				*aas = s+8;
+			goto retinf;
+		}
+		if(xcmp(s, "inf") == 0) {
+			if(aas != nil)
+				*aas = s+3;
+			goto retinf;
+		}
+	case S3:
+		if(aas != nil)
+			*aas = (char*)as;
+		goto ret0;	/* no digits found */
+	case S6:
+		s--;		/* back over +- */
+	case S5:
+		s--;		/* back over e */
+		break;
+	}
+	if(aas != nil)
+		*aas = s;
+
+	if(flag & Fdpoint)
+	while(na > 0 && a[na-1] == '0')
+		na--;
+	if(na == 0)
+		goto ret0;	/* zero */
+	a[na] = 0;
+	if(!(flag & Fdpoint))
+		dp = na;
+	if(flag & Fesign)
+		ex = -ex;
+	dp += ex;
+	if(dp < -Maxe){
+		errno = ERANGE;
+		goto ret0;	/* underflow by exp */
+	} else
+	if(dp > +Maxe)
+		goto retinf;	/* overflow by exp */
+
+	/*
+	 * normalize the decimal ascii number
+	 * to range .[5-9][0-9]* e0
+	 */
+	bp = 0;		/* binary exponent */
+	while(dp > 0)
+		divascii(a, &na, &dp, &bp);
+	while(dp < 0 || a[0] < '5')
+		mulascii(a, &na, &dp, &bp);
+
+	/* close approx by naive conversion */
+	mid[0] = 0;
+	mid[1] = 1;
+	for(i=0; c=a[i]; i++) {
+		mid[0] = mid[0]*10 + (c-'0');
+		mid[1] = mid[1]*10;
+		if(i >= 8)
+			break;
+	}
+	low[0] = umuldiv(mid[0], One, mid[1]);
+	hig[0] = umuldiv(mid[0]+1, One, mid[1]);
+	for(i=1; i<Prec; i++) {
+		low[i] = 0;
+		hig[i] = One-1;
+	}
+
+	/* binary search for closest mantissa */
+	for(;;) {
+		/* mid = (hig + low) / 2 */
+		c = 0;
+		for(i=0; i<Prec; i++) {
+			mid[i] = hig[i] + low[i];
+			if(c)
+				mid[i] += One;
+			c = mid[i] & 1;
+			mid[i] >>= 1;
+		}
+		frnorm(mid);
+
+		/* compare */
+		c = fpcmp(a, mid);
+		if(c > 0) {
+			c = 1;
+			for(i=0; i<Prec; i++)
+				if(low[i] != mid[i]) {
+					c = 0;
+					low[i] = mid[i];
+				}
+			if(c)
+				break;	/* between mid and hig */
+			continue;
+		}
+		if(c < 0) {
+			for(i=0; i<Prec; i++)
+				hig[i] = mid[i];
+			continue;
+		}
+
+		/* only hard part is if even/odd roundings wants to go up */
+		c = mid[Prec-1] & (Sigbit-1);
+		if(c == Sigbit/2 && (mid[Prec-1]&Sigbit) == 0)
+			mid[Prec-1] -= c;
+		break;	/* exactly mid */
+	}
+
+	/* normal rounding applies */
+	c = mid[Prec-1] & (Sigbit-1);
+	mid[Prec-1] -= c;
+	if(c >= Sigbit/2) {
+		mid[Prec-1] += Sigbit;
+		frnorm(mid);
+	}
+	goto out;
+
+ret0:
+	return 0;
+
+retnan:
+	return __NaN();
+
+retinf:
+	/*
+	 * Unix strtod requires these.  Plan 9 would return Inf(0) or Inf(-1). */
+	errno = ERANGE;
+	if(flag & Fsign)
+		return -HUGE_VAL;
+	return HUGE_VAL;
+
+out:
+	d = 0;
+	for(i=0; i<Prec; i++)
+		d = d*One + mid[i];
+	if(flag & Fsign)
+		d = -d;
+	d = ldexp(d, bp - Prec*Nbits);
+	if(d == 0){	/* underflow */
+		errno = ERANGE;
+	}
+	return d;
+}
+
+static void
+frnorm(ulong *f)
+{
+	int i, c;
+
+	c = 0;
+	for(i=Prec-1; i>0; i--) {
+		f[i] += c;
+		c = f[i] >> Nbits;
+		f[i] &= One-1;
+	}
+	f[0] += c;
+}
+
+static int
+fpcmp(char *a, ulong* f)
+{
+	ulong tf[Prec];
+	int i, d, c;
+
+	for(i=0; i<Prec; i++)
+		tf[i] = f[i];
+
+	for(;;) {
+		/* tf *= 10 */
+		for(i=0; i<Prec; i++)
+			tf[i] = tf[i]*10;
+		frnorm(tf);
+		d = (tf[0] >> Nbits) + '0';
+		tf[0] &= One-1;
+
+		/* compare next digit */
+		c = *a;
+		if(c == 0) {
+			if('0' < d)
+				return -1;
+			if(tf[0] != 0)
+				goto cont;
+			for(i=1; i<Prec; i++)
+				if(tf[i] != 0)
+					goto cont;
+			return 0;
+		}
+		if(c > d)
+			return +1;
+		if(c < d)
+			return -1;
+		a++;
+	cont:;
+	}
+}
+
+static void
+divby(char *a, int *na, int b)
+{
+	int n, c;
+	char *p;
+
+	p = a;
+	n = 0;
+	while(n>>b == 0) {
+		c = *a++;
+		if(c == 0) {
+			while(n) {
+				c = n*10;
+				if(c>>b)
+					break;
+				n = c;
+			}
+			goto xx;
+		}
+		n = n*10 + c-'0';
+		(*na)--;
+	}
+	for(;;) {
+		c = n>>b;
+		n -= c<<b;
+		*p++ = c + '0';
+		c = *a++;
+		if(c == 0)
+			break;
+		n = n*10 + c-'0';
+	}
+	(*na)++;
+xx:
+	while(n) {
+		n = n*10;
+		c = n>>b;
+		n -= c<<b;
+		*p++ = c + '0';
+		(*na)++;
+	}
+	*p = 0;
+}
+
+static	Tab	tab1[] =
+{
+	 1,  0, "",
+	 3,  1, "7",
+	 6,  2, "63",
+	 9,  3, "511",
+	13,  4, "8191",
+	16,  5, "65535",
+	19,  6, "524287",
+	23,  7, "8388607",
+	26,  8, "67108863",
+	27,  9, "134217727",
+};
+
+static void
+divascii(char *a, int *na, int *dp, int *bp)
+{
+	int b, d;
+	Tab *t;
+
+	d = *dp;
+	if(d >= (int)(nelem(tab1)))
+		d = (int)(nelem(tab1))-1;
+	t = tab1 + d;
+	b = t->bp;
+	if(memcmp(a, t->cmp, t->siz) > 0)
+		d--;
+	*dp -= d;
+	*bp += b;
+	divby(a, na, b);
+}
+
+static void
+mulby(char *a, char *p, char *q, int b)
+{
+	int n, c;
+
+	n = 0;
+	*p = 0;
+	for(;;) {
+		q--;
+		if(q < a)
+			break;
+		c = *q - '0';
+		c = (c<<b) + n;
+		n = c/10;
+		c -= n*10;
+		p--;
+		*p = c + '0';
+	}
+	while(n) {
+		c = n;
+		n = c/10;
+		c -= n*10;
+		p--;
+		*p = c + '0';
+	}
+}
+
+static	Tab	tab2[] =
+{
+	 1,  1, "",				/* dp = 0-0 */
+	 3,  3, "125",
+	 6,  5, "15625",
+	 9,  7, "1953125",
+	13, 10, "1220703125",
+	16, 12, "152587890625",
+	19, 14, "19073486328125",
+	23, 17, "11920928955078125",
+	26, 19, "1490116119384765625",
+	27, 19, "7450580596923828125",		/* dp 8-9 */
+};
+
+static void
+mulascii(char *a, int *na, int *dp, int *bp)
+{
+	char *p;
+	int d, b;
+	Tab *t;
+
+	d = -*dp;
+	if(d >= (int)(nelem(tab2)))
+		d = (int)(nelem(tab2))-1;
+	t = tab2 + d;
+	b = t->bp;
+	if(memcmp(a, t->cmp, t->siz) < 0)
+		d--;
+	p = a + *na;
+	*bp -= b;
+	*dp += d;
+	*na += d;
+	mulby(a, p+d, p, b);
+}
+
+static int
+xcmp(char *a, char *b)
+{
+	int c1, c2;
+
+	while(c1 = *b++) {
+		c2 = *a++;
+		if(isupper(c2))
+			c2 = tolower(c2);
+		if(c1 != c2)
+			return 1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/strtod.h b/sys/src/ape/lib/fmt/strtod.h
new file mode 100755
index 000000000..82c3d46eb
--- /dev/null
+++ b/sys/src/ape/lib/fmt/strtod.h
@@ -0,0 +1,4 @@
+extern double __NaN(void);
+extern double __Inf(int);
+extern double __isNaN(double);
+extern double __isInf(double, int);
diff --git a/sys/src/ape/lib/fmt/test.c b/sys/src/ape/lib/fmt/test.c
new file mode 100755
index 000000000..a1a1d5edc
--- /dev/null
+++ b/sys/src/ape/lib/fmt/test.c
@@ -0,0 +1,39 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <utf.h>
+#include "fmt.h"
+
+int
+main(int argc, char *argv[])
+{
+	quotefmtinstall();
+	print("hello world\n");
+	print("x: %x\n", 0x87654321);
+	print("u: %u\n", 0x87654321);
+	print("d: %d\n", 0x87654321);
+	print("s: %s\n", "hi there");
+	print("q: %q\n", "hi i'm here");
+	print("c: %c\n", '!');
+	print("g: %g %g %g\n", 3.14159, 3.14159e10, 3.14159e-10);
+	print("e: %e %e %e\n", 3.14159, 3.14159e10, 3.14159e-10);
+	print("f: %f %f %f\n", 3.14159, 3.14159e10, 3.14159e-10);
+	print("smiley: %C\n", (Rune)0x263a);
+	print("%g %.18\n", 2e25, 2e25);
+	print("%2.18g\n", 1.0);
+	print("%f\n", 3.1415927/4);
+	print("%d\n", 23);
+	print("%i\n", 23);
+	return 0;
+}
diff --git a/sys/src/ape/lib/fmt/vfprint.c b/sys/src/ape/lib/fmt/vfprint.c
new file mode 100755
index 000000000..e4ab82acb
--- /dev/null
+++ b/sys/src/ape/lib/fmt/vfprint.c
@@ -0,0 +1,31 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+vfprint(int fd, char *fmt, va_list args)
+{
+	Fmt f;
+	char buf[256];
+	int n;
+
+	fmtfdinit(&f, fd, buf, sizeof(buf));
+	f.args = args;
+	n = dofmt(&f, fmt);
+	if(n > 0 && __fmtFdFlush(&f) == 0)
+		return -1;
+	return n;
+}
diff --git a/sys/src/ape/lib/fmt/vseprint.c b/sys/src/ape/lib/fmt/vseprint.c
new file mode 100755
index 000000000..85ed810bd
--- /dev/null
+++ b/sys/src/ape/lib/fmt/vseprint.c
@@ -0,0 +1,37 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+char*
+vseprint(char *buf, char *e, char *fmt, va_list args)
+{
+	Fmt f;
+
+	if(e <= buf)
+		return nil;
+	f.runes = 0;
+	f.start = buf;
+	f.to = buf;
+	f.stop = e - 1;
+	f.flush = 0;
+	f.farg = nil;
+	f.nfmt = 0;
+	f.args = args;
+	dofmt(&f, fmt);
+	*(char*)f.to = '\0';
+	return (char*)f.to;
+}
+
diff --git a/sys/src/ape/lib/fmt/vsmprint.c b/sys/src/ape/lib/fmt/vsmprint.c
new file mode 100755
index 000000000..38ace62d7
--- /dev/null
+++ b/sys/src/ape/lib/fmt/vsmprint.c
@@ -0,0 +1,36 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+/*
+ * print into an allocated string buffer
+ */
+char*
+vsmprint(char *fmt, va_list args)
+{
+	Fmt f;
+	int n;
+
+	if(fmtstrinit(&f) < 0)
+		return nil;
+	f.args = args;
+	n = dofmt(&f, fmt);
+	if(n < 0)
+		return nil;
+	*(char*)f.to = '\0';
+	return (char*)f.start;
+}
diff --git a/sys/src/ape/lib/fmt/vsnprint.c b/sys/src/ape/lib/fmt/vsnprint.c
new file mode 100755
index 000000000..21662e6d4
--- /dev/null
+++ b/sys/src/ape/lib/fmt/vsnprint.c
@@ -0,0 +1,37 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include "fmt.h"
+#include "fmtdef.h"
+
+int
+vsnprint(char *buf, int len, char *fmt, va_list args)
+{
+	Fmt f;
+
+	if(len <= 0)
+		return -1;
+	f.runes = 0;
+	f.start = buf;
+	f.to = buf;
+	f.stop = buf + len - 1;
+	f.flush = 0;
+	f.farg = nil;
+	f.nfmt = 0;
+	f.args = args;
+	dofmt(&f, fmt);
+	*(char*)f.to = '\0';
+	return (char*)f.to - buf;
+}
diff --git a/sys/src/ape/lib/fmt/werrstr.c b/sys/src/ape/lib/fmt/werrstr.c
new file mode 100755
index 000000000..05222f72e
--- /dev/null
+++ b/sys/src/ape/lib/fmt/werrstr.c
@@ -0,0 +1,16 @@
+#include <stdarg.h>
+#include <errno.h>
+#include "fmt.h"
+
+extern char _plan9err[128];
+
+void
+werrstr(const char *fmt, ...)
+{
+	va_list arg;
+
+	va_start(arg, fmt);
+	snprint(_plan9err, sizeof _plan9err, fmt, arg);
+	va_end(arg);
+	errno = EPLAN9;
+}
diff --git a/sys/src/ape/lib/l/allprint.c b/sys/src/ape/lib/l/allprint.c
new file mode 100755
index 000000000..c0e8296be
--- /dev/null
+++ b/sys/src/ape/lib/l/allprint.c
@@ -0,0 +1,38 @@
+#include	<libl.h>
+#include	<stdio.h>
+
+extern	FILE*	yyout;
+
+int
+printable(int c)
+{
+	return 040 < c && c < 0177;
+}
+
+void
+allprint(char c)
+{
+
+	switch(c) {
+	case '\n':
+		fprintf(yyout,"\\n");
+		break;
+	case '\t':
+		fprintf(yyout,"\\t");
+		break;
+	case '\b':
+		fprintf(yyout,"\\b");
+		break;
+	case ' ':
+		fprintf(yyout,"\\\bb");
+		break;
+	default:
+		if(!printable(c))
+			fprintf(yyout,"\\%-3o",c);
+		else 
+			c = putc(c,yyout);
+			USED(c);
+		break;
+	}
+	return;
+}
diff --git a/sys/src/ape/lib/l/main.c b/sys/src/ape/lib/l/main.c
new file mode 100755
index 000000000..48025e334
--- /dev/null
+++ b/sys/src/ape/lib/l/main.c
@@ -0,0 +1,12 @@
+#include	<libl.h>
+#include	<stdlib.h>
+
+int	yylex(void);
+
+void
+main(int argc, char *argv[])
+{
+	USED(argc);
+	yylex();
+	exit(0);
+}
diff --git a/sys/src/ape/lib/l/mkfile b/sys/src/ape/lib/l/mkfile
new file mode 100755
index 000000000..15c1e5c4a
--- /dev/null
+++ b/sys/src/ape/lib/l/mkfile
@@ -0,0 +1,13 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libl.a
+OFILES=allprint.$O\
+	main.$O\
+	reject.$O\
+	yyless.$O\
+	yywrap.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_RESEARCH_SOURCE
diff --git a/sys/src/ape/lib/l/reject.c b/sys/src/ape/lib/l/reject.c
new file mode 100755
index 000000000..0b2aa7c5d
--- /dev/null
+++ b/sys/src/ape/lib/l/reject.c
@@ -0,0 +1,57 @@
+#include	<libl.h>
+#include	<stdio.h>
+
+extern	FILE*	yyout;
+extern	FILE*	yyin;
+extern	int	yyprevious, *yyfnd;
+extern	char	yyextra[];
+extern	char	yytext[];
+extern	int	yyleng;
+
+extern
+struct
+{
+	int *yyaa, *yybb;
+	int *yystops;
+} *yylstate [], **yylsp, **yyolsp;
+
+int	yyback(int *p, int m);
+int	yyinput(void);
+void	yyoutput(int c);
+void	yyunput(int c);
+
+int
+yyracc(int m)
+{
+
+	yyolsp = yylsp;
+	if(yyextra[m]) {
+		while(yyback((*yylsp)->yystops, -m) != 1 && yylsp > yylstate) {
+			yylsp--;
+			yyunput(yytext[--yyleng]);
+		}
+	}
+	yyprevious = yytext[yyleng-1];
+	yytext[yyleng] = 0;
+	return m;
+}
+
+int
+yyreject(void)
+{
+	for(; yylsp < yyolsp; yylsp++)
+		yytext[yyleng++] = yyinput();
+	if(*yyfnd > 0)
+		return yyracc(*yyfnd++);
+	while(yylsp-- > yylstate) {
+		yyunput(yytext[yyleng-1]);
+		yytext[--yyleng] = 0;
+		if(*yylsp != 0 && (yyfnd = (*yylsp)->yystops) && *yyfnd > 0)
+			return yyracc(*yyfnd++);
+	}
+	if(yytext[0] == 0)
+		return 0;
+	yyoutput(yyprevious = yyinput());
+	yyleng = 0;
+	return -1;
+}
diff --git a/sys/src/ape/lib/l/yyless.c b/sys/src/ape/lib/l/yyless.c
new file mode 100755
index 000000000..9367919f3
--- /dev/null
+++ b/sys/src/ape/lib/l/yyless.c
@@ -0,0 +1,26 @@
+#include	<libl.h>
+#include	<stdio.h>
+
+extern	char	yytext[];
+extern	int	yyleng;
+extern	int	yyprevious;
+
+void	yyunput(int c);
+
+void
+yyless(int x)
+{
+	char *lastch, *ptr;
+
+	lastch = yytext+yyleng;
+	if(x>=0 && x <= yyleng)
+		ptr = x + yytext;
+	else
+		ptr = (char*)x;
+	while(lastch > ptr)
+		yyunput(*--lastch);
+	*lastch = 0;
+	if (ptr >yytext)
+		yyprevious = *--lastch;
+	yyleng = ptr-yytext;
+}
diff --git a/sys/src/ape/lib/l/yywrap.c b/sys/src/ape/lib/l/yywrap.c
new file mode 100755
index 000000000..772ee0ae5
--- /dev/null
+++ b/sys/src/ape/lib/l/yywrap.c
@@ -0,0 +1,8 @@
+#include	<libl.h>
+#include	<stdio.h>
+
+int
+yywrap(void)
+{
+	return 1;
+}
diff --git a/sys/src/ape/lib/mkfile b/sys/src/ape/lib/mkfile
new file mode 100755
index 000000000..91d286721
--- /dev/null
+++ b/sys/src/ape/lib/mkfile
@@ -0,0 +1,12 @@
+</$objtype/mkfile
+
+DIRS=`{ls -l | sed '/^d/!d; s/.* //; /\./d'}
+
+none:V:
+	echo mk all, install, installall, clean, or nuke
+
+all clean nuke install installall:V:
+	for (i in $DIRS) @{
+		cd $i
+		mk $target
+	}
diff --git a/sys/src/ape/lib/net/announce.c b/sys/src/ape/lib/net/announce.c
new file mode 100755
index 000000000..807239f5d
--- /dev/null
+++ b/sys/src/ape/lib/net/announce.c
@@ -0,0 +1,222 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <libnet.h>
+
+#define NAMELEN 28
+
+static int	nettrans(char*, char*, int na, char*, int);
+
+/*
+ *  announce a network service.
+ */
+int
+announce(char *addr, char *dir)
+{
+	int ctl, n, m;
+	char buf[3*NAMELEN];
+	char buf2[3*NAMELEN];
+	char netdir[2*NAMELEN];
+	char naddr[3*NAMELEN];
+	char *cp;
+
+	/*
+	 *  translate the address
+	 */
+	if(nettrans(addr, naddr, sizeof(naddr), netdir, sizeof(netdir)) < 0)
+		return -1;
+
+	/*
+	 * get a control channel
+	 */
+	ctl = open(netdir, O_RDWR);
+	if(ctl<0)
+		return -1;
+	cp = strrchr(netdir, '/');
+	*cp = 0;
+
+	/*
+	 *  find out which line we have
+	 */
+	n = sprintf(buf, "%.*s/", 2*NAMELEN+1, netdir);
+	m = read(ctl, &buf[n], sizeof(buf)-n-1);
+	if(n<=0){
+		close(ctl);
+		return -1;
+	}
+	buf[n+m] = 0;
+
+	/*
+	 *  make the call
+	 */
+	n = sprintf(buf2, "announce %.*s", 2*NAMELEN, naddr);
+	if(write(ctl, buf2, n)!=n){
+		close(ctl);
+		return -1;
+	}
+
+	/*
+	 *  return directory etc.
+	 */
+	if(dir)
+		strcpy(dir, buf);
+	return ctl;
+}
+
+/*
+ *  listen for an incoming call
+ */
+int
+listen(char *dir, char *newdir)
+{
+	int ctl, n, m;
+	char buf[3*NAMELEN];
+	char *cp;
+
+	/*
+	 *  open listen, wait for a call
+	 */
+	sprintf(buf, "%.*s/listen", 2*NAMELEN+1, dir);
+	ctl = open(buf, O_RDWR);
+	if(ctl < 0)
+		return -1;
+
+	/*
+	 *  find out which line we have
+	 */
+	strcpy(buf, dir);
+	cp = strrchr(buf, '/');
+	*++cp = 0;
+	n = cp-buf;
+	m = read(ctl, cp, sizeof(buf) - n - 1);
+	if(n<=0){
+		close(ctl);
+		return -1;
+	}
+	buf[n+m] = 0;
+
+	/*
+	 *  return directory etc.
+	 */
+	if(newdir)
+		strcpy(newdir, buf);
+	return ctl;
+
+}
+
+/*
+ *  accept a call, return an fd to the open data file
+ */
+int
+accept(int ctl, char *dir)
+{
+	char buf[128];
+	char *num;
+	long n;
+
+	num = strrchr(dir, '/');
+	if(num == 0)
+		num = dir;
+	else
+		num++;
+
+	sprintf(buf, "accept %s", num);
+	n = strlen(buf);
+	write(ctl, buf, n); /* ignore return value, netowrk might not need accepts */
+
+	sprintf(buf, "%s/data", dir);
+	return open(buf, O_RDWR);
+}
+
+/*
+ *  reject a call, tell device the reason for the rejection
+ */
+int
+reject(int ctl, char *dir, char *cause)
+{
+	char buf[128];
+	char *num;
+	long n;
+
+	num = strrchr(dir, '/');
+	if(num == 0)
+		num = dir;
+	else
+		num++;
+	sprintf(buf, "reject %s %s", num, cause);
+	n = strlen(buf);
+	if(write(ctl, buf, n) != n)
+		return -1;
+	return 0;
+}
+
+/*
+ *  perform the identity translation (in case we can't reach cs)
+ */
+static int
+identtrans(char *addr, char *naddr, int na, char *file, int nf)
+{
+	char reply[4*NAMELEN];
+	char *p;
+
+	USED(nf);
+
+	/* parse the network */
+	strncpy(reply, addr, sizeof(reply));
+	reply[sizeof(reply)-1] = 0;
+	p = strchr(addr, '!');
+	if(p)
+		*p++ = 0;
+
+	sprintf(file, "/net/%.*s/clone", na - sizeof("/net//clone"), reply);
+	strncpy(naddr, p, na);
+	naddr[na-1] = 0;
+
+	return 1;
+}
+
+/*
+ *  call up the connection server and get a translation
+ */
+static int
+nettrans(char *addr, char *naddr, int na, char *file, int nf)
+{
+	int fd;
+	char reply[4*NAMELEN];
+	char *cp;
+	long n;
+
+	/*
+	 *  ask the connection server
+	 */
+	fd = open("/net/cs", O_RDWR);
+	if(fd < 0)
+		return identtrans(addr, naddr, na, file, nf);
+	if(write(fd, addr, strlen(addr)) < 0){
+		close(fd);
+		return -1;
+	}
+	lseek(fd, 0, 0);
+	n = read(fd, reply, sizeof(reply)-1);
+	close(fd);
+	if(n <= 0)
+		return -1;
+	reply[n] = 0;
+
+	/*
+	 *  parse the reply
+	 */
+	cp = strchr(reply, ' ');
+	if(cp == 0)
+		return -1;
+	*cp++ = 0;
+	strncpy(naddr, cp, na);
+	naddr[na-1] = 0;
+	strncpy(file, reply, nf);
+	file[nf-1] = 0;
+	return 0;
+}
diff --git a/sys/src/ape/lib/net/dial.c b/sys/src/ape/lib/net/dial.c
new file mode 100755
index 000000000..712c6148f
--- /dev/null
+++ b/sys/src/ape/lib/net/dial.c
@@ -0,0 +1,128 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <libnet.h>
+
+#define NAMELEN 28
+
+static int
+call(char *clone, char *dest, int *cfdp, char *dir, char *local)
+{
+	int fd, cfd;
+	int n;
+	char name[3*NAMELEN+5];
+	char data[3*NAMELEN+10];
+	char *p;
+
+	cfd = open(clone, O_RDWR);
+	if(cfd < 0)
+		return -1;
+
+	/* get directory name */
+	n = read(cfd, name, sizeof(name)-1);
+	if(n < 0){
+		close(cfd);
+		return -1;
+	}
+	name[n] = 0;
+	p = strrchr(clone, '/');
+	*p = 0;
+	if(dir)
+		sprintf(dir, "%.*s/%.*s", 2*NAMELEN+1, clone, NAMELEN, name);
+	sprintf(data, "%.*s/%.*s/data", 2*NAMELEN+1, clone, NAMELEN, name);
+
+	/* set local side (port number, for example) if we need to */
+	if(local)
+		sprintf(name, "connect %.*s %.*s", 2*NAMELEN, dest, NAMELEN, local);
+	else
+		sprintf(name, "connect %.*s", 2*NAMELEN, dest);
+
+	/* connect */
+	if(write(cfd, name, strlen(name)) < 0){
+		close(cfd);
+		return -1;
+	}
+
+	/* open data connection */
+	fd = open(data, O_RDWR);
+	if(fd < 0){
+		close(cfd);
+		return -1;
+	}
+	if(cfdp)
+		*cfdp = cfd;
+	else
+		close(cfd);
+	return fd;
+}
+
+int
+dial(char *dest, char *local, char *dir, int *cfdp)
+{
+	char net[128];
+	char netdir[128], csname[NETPATHLEN], *slp;
+	char clone[NAMELEN+12];
+	char *p;
+	int n;
+	int fd;
+	int rv;
+
+	/* go for a standard form net!... */
+	p = strchr(dest, '!');
+	if(p == 0){
+		sprintf(net, "net!%.*s", sizeof(net)-5, dest);
+	} else {
+		strncpy(net, dest, sizeof(net)-1);
+		net[sizeof(net)-1] = 0;
+	}
+
+	slp = strrchr(net, '/');
+	if (slp != 0) {
+		*slp++ = '\0';
+		strcpy(netdir, net);
+		memmove(net, slp, strlen(slp)+1);
+	} else
+		strcpy(netdir, "/net");
+ 
+
+	/* call the connection server */
+	sprintf(csname, "%s/cs", netdir);
+	fd = open(csname, O_RDWR);
+	if(fd < 0){
+		/* no connection server, don't translate */
+		p = strchr(net, '!');
+		*p++ = 0;
+		sprintf(clone, "%s/%s/clone", netdir, net);
+		return call(clone, p, cfdp, dir, local);
+	}
+
+	/*
+	 *  send dest to connection to translate
+	 */
+	if(write(fd, net, strlen(net)) < 0){
+		close(fd);
+		return -1;
+	}
+
+	/*
+	 *  loop through each address from the connection server till
+	 *  we get one that works.
+	 */
+	rv = -1;
+	lseek(fd, 0, 0);
+	while((n = read(fd, net, sizeof(net) - 1)) > 0){
+		net[n] = 0;
+		p = strchr(net, ' ');
+		if(p == 0)
+			continue;
+		*p++ = 0;
+		rv = call(net, p, cfdp, dir, local);
+		if(rv >= 0)
+			break;
+	}
+	close(fd);
+	return rv;
+}
diff --git a/sys/src/ape/lib/net/hangup.c b/sys/src/ape/lib/net/hangup.c
new file mode 100755
index 000000000..920ac1cdd
--- /dev/null
+++ b/sys/src/ape/lib/net/hangup.c
@@ -0,0 +1,16 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <libnet.h>
+
+/*
+ *  force a connection to hangup
+ */
+int
+hangup(int ctl)
+{
+	return write(ctl, "hangup", sizeof("hangup")-1) != sizeof("hangup")-1;
+}
diff --git a/sys/src/ape/lib/net/mkfile b/sys/src/ape/lib/net/mkfile
new file mode 100755
index 000000000..49539c079
--- /dev/null
+++ b/sys/src/ape/lib/net/mkfile
@@ -0,0 +1,13 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libnet.a
+OFILES=dial.$O\
+	announce.$O\
+	netmkaddr.$O\
+	hangup.$O\
+	
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_RESEARCH_SOURCE -D_NET_EXTENSION
diff --git a/sys/src/ape/lib/net/netmkaddr.c b/sys/src/ape/lib/net/netmkaddr.c
new file mode 100755
index 000000000..52b9710a0
--- /dev/null
+++ b/sys/src/ape/lib/net/netmkaddr.c
@@ -0,0 +1,56 @@
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <libnet.h>
+
+/*
+ *  make an address, add the defaults
+ */
+char *
+netmkaddr(char *linear, char *defnet, char *defsrv)
+{
+	static char addr[256];
+	char *cp;
+
+	/*
+	 *  dump network name
+	 */
+	cp = strchr(linear, '!');
+	if(cp == 0){
+		if(defnet==0){
+			if(defsrv)
+				snprintf(addr, sizeof(addr), "net!%s!%s",
+					linear, defsrv);
+			else
+				snprintf(addr, sizeof(addr), "net!%s", linear);
+		}
+		else {
+			if(defsrv)
+				snprintf(addr, sizeof(addr), "%s!%s!%s", defnet,
+					linear, defsrv);
+			else
+				snprintf(addr, sizeof(addr), "%s!%s", defnet,
+					linear);
+		}
+		return addr;
+	}
+
+	/*
+	 *  if there is already a service, use it
+	 */
+	cp = strchr(cp+1, '!');
+	if(cp)
+		return linear;
+
+	/*
+	 *  add default service
+	 */
+	if(defsrv == 0)
+		return linear;
+	snprintf(addr, sizeof(addr), "%s!%s", linear, defsrv);
+
+	return addr;
+}
diff --git a/sys/src/ape/lib/regexp/mkfile b/sys/src/ape/lib/regexp/mkfile
new file mode 100755
index 000000000..e5d8bc209
--- /dev/null
+++ b/sys/src/ape/lib/regexp/mkfile
@@ -0,0 +1,15 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libregexp.a
+OFILES=regcomp.$O\
+	regerror.$O\
+	regexec.$O\
+	regsub.$O\
+	regaux.$O\
+	rregexec.$O\
+	rregsub.$O\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -DUTF -D_REGEXP_EXTENSION
diff --git a/sys/src/ape/lib/regexp/regaux.c b/sys/src/ape/lib/regexp/regaux.c
new file mode 100755
index 000000000..6643b8ff8
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regaux.c
@@ -0,0 +1,56 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "regexp.h"
+#include "regcomp.h"
+
+/*
+ *	Machine state
+ */
+Relist*	_relist[2];
+Relist*	_reliste[2];
+int	_relistsize = LISTINCREMENT;
+
+/*
+ *  save a new match in mp
+ */
+extern void
+_renewmatch(Resub *mp, int ms, Resublist *sp)
+{
+	int i;
+
+	if(mp==0 || ms<=0)
+		return;
+	if(mp[0].s.sp==0 || sp->m[0].s.sp<mp[0].s.sp ||
+	   (sp->m[0].s.sp==mp[0].s.sp && sp->m[0].e.ep>mp[0].e.ep)){
+		for(i=0; i<ms && i<NSUBEXP; i++)
+			mp[i] = sp->m[i];
+		for(; i<ms; i++)
+			mp[i].s.sp = mp[i].e.ep = 0;
+	}
+}
+
+/*
+ * Note optimization in _renewthread:
+ * 	*lp must be pending when _renewthread called; if *l has been looked
+ *		at already, the optimization is a bug.
+ */
+extern Relist*
+_renewthread(Relist *lp,	/* _relist to add to */
+	Reinst *ip,	/* instruction to add */
+	Resublist *sep)	/* pointers to subexpressions */
+{
+	Relist *p;
+
+	for(p=lp; p->inst; p++){
+		if(p->inst == ip){
+			if((sep)->m[0].s.sp < p->se.m[0].s.sp)
+				p->se = *sep;
+			return 0;
+		}
+	}
+	p->inst = ip;
+	p->se = *sep;
+	(++p)->inst = 0;
+	return p;
+}
+
diff --git a/sys/src/ape/lib/regexp/regcomp.c b/sys/src/ape/lib/regexp/regcomp.c
new file mode 100755
index 000000000..5d31fc2f6
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regcomp.c
@@ -0,0 +1,560 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <string.h>
+#include "regexp.h"
+#include "regcomp.h"
+
+#define	TRUE	1
+#define	FALSE	0
+
+/*
+ * Parser Information
+ */
+typedef
+struct Node
+{
+	Reinst*	first;
+	Reinst*	last;
+}Node;
+
+#define	NSTACK	20
+static	Node	andstack[NSTACK];
+static	Node	*andp;
+static	int	atorstack[NSTACK];
+static	int*	atorp;
+static	int	cursubid;		/* id of current subexpression */
+static	int	subidstack[NSTACK];	/* parallel to atorstack */
+static	int*	subidp;
+static	int	lastwasand;	/* Last token was operand */
+static	int	nbra;
+static	char*	exprp;		/* pointer to next character in source expression */
+static	int	lexdone;
+static	int	nclass;
+static	Reclass*classp;
+static	Reinst*	freep;
+static	int	errors;
+static	wchar_t	yyrune;		/* last lex'd rune */
+static	Reclass*yyclassp;	/* last lex'd class */
+
+/* predeclared crap */
+static	void	operator(int);
+static	void	pushand(Reinst*, Reinst*);
+static	void	pushator(int);
+static	void	evaluntil(int);
+static	int	bldcclass(void);
+
+static jmp_buf regkaboom;
+
+static	void
+rcerror(char *s)
+{
+	errors++;
+	regerror(s);
+	longjmp(regkaboom, 1);
+}
+
+static	Reinst*
+newinst(int t)
+{
+	freep->type = t;
+	freep->l.left = 0;
+	freep->r.right = 0;
+	return freep++;
+}
+
+static	void
+operand(int t)
+{
+	Reinst *i;
+
+	if(lastwasand)
+		operator(CAT);	/* catenate is implicit */
+	i = newinst(t);
+
+	if(t == CCLASS || t == NCCLASS)
+		i->r.cp = yyclassp;
+	if(t == RUNE)
+		i->r.r = yyrune;
+
+	pushand(i, i);
+	lastwasand = TRUE;
+}
+
+static	void
+operator(int t)
+{
+	if(t==RBRA && --nbra<0)
+		rcerror("unmatched right paren");
+	if(t==LBRA){
+		if(++cursubid >= NSUBEXP)
+			rcerror ("too many subexpressions");
+		nbra++;
+		if(lastwasand)
+			operator(CAT);
+	} else
+		evaluntil(t);
+	if(t != RBRA)
+		pushator(t);
+	lastwasand = FALSE;
+	if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
+		lastwasand = TRUE;	/* these look like operands */
+}
+
+static	void
+regerr2(char *s, int c)
+{
+	char buf[100];
+	char *cp = buf;
+	while(*s)
+		*cp++ = *s++;
+	*cp++ = c;
+	*cp = '\0'; 
+	rcerror(buf);
+}
+
+static	void
+cant(char *s)
+{
+	char buf[100];
+	strcpy(buf, "can't happen: ");
+	strcat(buf, s);
+	rcerror(buf);
+}
+
+static	void
+pushand(Reinst *f, Reinst *l)
+{
+	if(andp >= &andstack[NSTACK])
+		cant("operand stack overflow");
+	andp->first = f;
+	andp->last = l;
+	andp++;
+}
+
+static	void
+pushator(int t)
+{
+	if(atorp >= &atorstack[NSTACK])
+		cant("operator stack overflow");
+	*atorp++ = t;
+	*subidp++ = cursubid;
+}
+
+static	Node*
+popand(int op)
+{
+	Reinst *inst;
+
+	if(andp <= &andstack[0]){
+		regerr2("missing operand for ", op);
+		inst = newinst(NOP);
+		pushand(inst,inst);
+	}
+	return --andp;
+}
+
+static	int
+popator(void)
+{
+	if(atorp <= &atorstack[0])
+		cant("operator stack underflow");
+	--subidp;
+	return *--atorp;
+}
+
+static	void
+evaluntil(int pri)
+{
+	Node *op1, *op2;
+	Reinst *inst1, *inst2;
+
+	while(pri==RBRA || atorp[-1]>=pri){
+		switch(popator()){
+		default:
+			rcerror("unknown operator in evaluntil");
+			break;
+		case LBRA:		/* must have been RBRA */
+			op1 = popand('(');
+			inst2 = newinst(RBRA);
+			inst2->r.subid = *subidp;
+			op1->last->l.next = inst2;
+			inst1 = newinst(LBRA);
+			inst1->r.subid = *subidp;
+			inst1->l.next = op1->first;
+			pushand(inst1, inst2);
+			return;
+		case OR:
+			op2 = popand('|');
+			op1 = popand('|');
+			inst2 = newinst(NOP);
+			op2->last->l.next = inst2;
+			op1->last->l.next = inst2;
+			inst1 = newinst(OR);
+			inst1->r.right = op1->first;
+			inst1->l.left = op2->first;
+			pushand(inst1, inst2);
+			break;
+		case CAT:
+			op2 = popand(0);
+			op1 = popand(0);
+			op1->last->l.next = op2->first;
+			pushand(op1->first, op2->last);
+			break;
+		case STAR:
+			op2 = popand('*');
+			inst1 = newinst(OR);
+			op2->last->l.next = inst1;
+			inst1->r.right = op2->first;
+			pushand(inst1, inst1);
+			break;
+		case PLUS:
+			op2 = popand('+');
+			inst1 = newinst(OR);
+			op2->last->l.next = inst1;
+			inst1->r.right = op2->first;
+			pushand(op2->first, inst1);
+			break;
+		case QUEST:
+			op2 = popand('?');
+			inst1 = newinst(OR);
+			inst2 = newinst(NOP);
+			inst1->l.left = inst2;
+			inst1->r.right = op2->first;
+			op2->last->l.next = inst2;
+			pushand(inst1, inst2);
+			break;
+		}
+	}
+}
+
+static	Reprog*
+optimize(Reprog *pp)
+{
+	Reinst *inst, *target;
+	int size;
+	Reprog *npp;
+	int diff;
+
+	/*
+	 *  get rid of NOOP chains
+	 */
+	for(inst=pp->firstinst; inst->type!=END; inst++){
+		target = inst->l.next;
+		while(target->type == NOP)
+			target = target->l.next;
+		inst->l.next = target;
+	}
+
+	/*
+	 *  The original allocation is for an area larger than
+	 *  necessary.  Reallocate to the actual space used
+	 *  and then relocate the code.
+	 */
+	size = sizeof(Reprog) + (freep - pp->firstinst)*sizeof(Reinst);
+	npp = realloc(pp, size);
+	if(npp==0 || npp==pp)
+		return pp;
+	diff = (char *)npp - (char *)pp;
+	freep = (Reinst *)((char *)freep + diff);
+	for(inst=npp->firstinst; inst<freep; inst++){
+		switch(inst->type){
+		case OR:
+		case STAR:
+		case PLUS:
+		case QUEST:
+		case CCLASS:
+		case NCCLASS:
+			*(char **)&inst->r.right += diff;
+			break;
+		}
+		*(char **)&inst->l.left += diff;
+	}
+	*(char **)&npp->startinst += diff;
+	return npp;
+}
+
+#ifdef	DEBUG
+static	void
+dumpstack(void){
+	Node *stk;
+	int *ip;
+
+	print("operators\n");
+	for(ip=atorstack; ip<atorp; ip++)
+		print("0%o\n", *ip);
+	print("operands\n");
+	for(stk=andstack; stk<andp; stk++)
+		print("0%o\t0%o\n", stk->first->type, stk->last->type);
+}
+
+static	void
+dump(Reprog *pp)
+{
+	Reinst *l;
+	wchar_t *p;
+
+	l = pp->firstinst;
+	do{
+		print("%d:\t0%o\t%d\t%d", l-pp->firstinst, l->type,
+			l->l.left-pp->firstinst, l->l.right-pp->firstinst);
+		if(l->type == RUNE)
+			print("\t%C\n", l->r);
+		else if(l->type == CCLASS || l->type == NCCLASS){
+			print("\t[");
+			if(l->type == NCCLASS)
+				print("^");
+			for(p = l->r.cp->spans; p < l->r.cp->end; p += 2)
+				if(p[0] == p[1])
+					print("%C", p[0]);
+				else
+					print("%C-%C", p[0], p[1]);
+			print("]\n");
+		} else
+			print("\n");
+	}while(l++->type);
+}
+#endif
+
+static	Reclass*
+newclass(void)
+{
+	if(nclass >= NCLASS)
+		regerr2("too many character classes; limit", NCLASS+'0');
+	return &(classp[nclass++]);
+}
+
+static	int
+nextc(wchar_t *rp)
+{
+	int n;
+
+	if(lexdone){
+		*rp = 0;
+		return 1;
+	}
+	n = mbtowc(rp, exprp, MB_CUR_MAX);
+	if (n <= 0)
+		n = 1;
+	exprp += n;
+	if(*rp == L'\\'){
+		n = mbtowc(rp, exprp, MB_CUR_MAX);
+		if (n <= 0)
+			n = 1;
+		exprp += n;
+		return 1;
+	}
+	if(*rp == 0)
+		lexdone = 1;
+	return 0;
+}
+
+static	int
+lex(int literal, int dot_type)
+{
+	int quoted;
+
+	quoted = nextc(&yyrune);
+	if(literal || quoted){
+		if(yyrune == 0)
+			return END;
+		return RUNE;
+	}
+
+	switch(yyrune){
+	case 0:
+		return END;
+	case L'*':
+		return STAR;
+	case L'?':
+		return QUEST;
+	case L'+':
+		return PLUS;
+	case L'|':
+		return OR;
+	case L'.':
+		return dot_type;
+	case L'(':
+		return LBRA;
+	case L')':
+		return RBRA;
+	case L'^':
+		return BOL;
+	case L'$':
+		return EOL;
+	case L'[':
+		return bldcclass();
+	}
+	return RUNE;
+}
+
+static int
+bldcclass(void)
+{
+	int type;
+	wchar_t r[NCCRUNE];
+	wchar_t *p, *ep, *np;
+	wchar_t rune;
+	int quoted;
+
+	/* we have already seen the '[' */
+	type = CCLASS;
+	yyclassp = newclass();
+
+	/* look ahead for negation */
+	ep = r;
+	quoted = nextc(&rune);
+	if(!quoted && rune == L'^'){
+		type = NCCLASS;
+		quoted = nextc(&rune);
+		*ep++ = L'\n';
+		*ep++ = L'\n';
+	}
+
+	/* parse class into a set of spans */
+	for(; ep<&r[NCCRUNE];){
+		if(rune == 0){
+			rcerror("malformed '[]'");
+			return 0;
+		}
+		if(!quoted && rune == L']')
+			break;
+		if(!quoted && rune == L'-'){
+			if(ep == r){
+				rcerror("malformed '[]'");
+				return 0;
+			}
+			quoted = nextc(&rune);
+			if((!quoted && rune == L']') || rune == 0){
+				rcerror("malformed '[]'");
+				return 0;
+			}
+			*(ep-1) = rune;
+		} else {
+			*ep++ = rune;
+			*ep++ = rune;
+		}
+		quoted = nextc(&rune);
+	}
+
+	/* sort on span start */
+	for(p = r; p < ep; p += 2){
+		for(np = p; np < ep; np += 2)
+			if(*np < *p){
+				rune = np[0];
+				np[0] = p[0];
+				p[0] = rune;
+				rune = np[1];
+				np[1] = p[1];
+				p[1] = rune;
+			}
+	}
+
+	/* merge spans */
+	np = yyclassp->spans;
+	p = r;
+	if(r == ep)
+		yyclassp->end = np;
+	else {
+		np[0] = *p++;
+		np[1] = *p++;
+		for(; p < ep; p += 2)
+			if(p[0] <= np[1]){
+				if(p[1] > np[1])
+					np[1] = p[1];
+			} else {
+				np += 2;
+				np[0] = p[0];
+				np[1] = p[1];
+			}
+		yyclassp->end = np+2;
+	}
+
+	return type;
+}
+
+static	Reprog*
+regcomp1(char *s, int literal, int dot_type)
+{
+	int token;
+	Reprog *pp;
+
+	/* get memory for the program */
+	pp = malloc(sizeof(Reprog) + 6*sizeof(Reinst)*strlen(s));
+	if(pp == 0){
+		regerror("out of memory");
+		return 0;
+	}
+	freep = pp->firstinst;
+	classp = pp->class;
+	errors = 0;
+
+	if(setjmp(regkaboom))
+		goto out;
+
+	/* go compile the sucker */
+	lexdone = 0;
+	exprp = s;
+	nclass = 0;
+	nbra = 0;
+	atorp = atorstack;
+	andp = andstack;
+	subidp = subidstack;
+	lastwasand = FALSE;
+	cursubid = 0;
+
+	/* Start with a low priority operator to prime parser */
+	pushator(START-1);
+	while((token = lex(literal, dot_type)) != END){
+		if((token&0300) == OPERATOR)
+			operator(token);
+		else
+			operand(token);
+	}
+
+	/* Close with a low priority operator */
+	evaluntil(START);
+
+	/* Force END */
+	operand(END);
+	evaluntil(START);
+#ifdef DEBUG
+	dumpstack();
+#endif
+	if(nbra)
+		rcerror("unmatched left paren");
+	--andp;	/* points to first and only operand */
+	pp->startinst = andp->first;
+#ifdef DEBUG
+	dump(pp);
+#endif
+	pp = optimize(pp);
+#ifdef DEBUG
+	print("start: %d\n", andp->first-pp->firstinst);
+	dump(pp);
+#endif
+out:
+	if(errors){
+		free(pp);
+		pp = 0;
+	}
+	return pp;
+}
+
+extern	Reprog*
+regcomp(char *s)
+{
+	return regcomp1(s, 0, ANY);
+}
+
+extern	Reprog*
+regcomplit(char *s)
+{
+	return regcomp1(s, 1, ANY);
+}
+
+extern	Reprog*
+regcompnl(char *s)
+{
+	return regcomp1(s, 0, ANYNL);
+}
diff --git a/sys/src/ape/lib/regexp/regcomp.h b/sys/src/ape/lib/regexp/regcomp.h
new file mode 100755
index 000000000..082e6137e
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regcomp.h
@@ -0,0 +1,61 @@
+/*
+ *  substitution list
+ */
+typedef struct Resublist	Resublist;
+struct	Resublist
+{
+	Resub	m[32];
+};
+
+/* max subexpressions per program */
+Resublist ReSuBlIsT;
+#define NSUBEXP (sizeof(ReSuBlIsT.m)/sizeof(Resub))
+
+/* max character classes per program */
+Reprog	RePrOg;
+#define	NCLASS	(sizeof(RePrOg.class)/sizeof(Reclass))
+
+/* max rune ranges per character class */
+#define NCCRUNE	(sizeof(Reclass)/sizeof(wchar_t))
+
+/*
+ * Actions and Tokens (Reinst types)
+ *
+ *	02xx are operators, value == precedence
+ *	03xx are tokens, i.e. operands for operators
+ */
+#define RUNE		0177
+#define	OPERATOR	0200	/* Bitmask of all operators */
+#define	START		0200	/* Start, used for marker on stack */
+#define	RBRA		0201	/* Right bracket, ) */
+#define	LBRA		0202	/* Left bracket, ( */
+#define	OR		0203	/* Alternation, | */
+#define	CAT		0204	/* Concatentation, implicit operator */
+#define	STAR		0205	/* Closure, * */
+#define	PLUS		0206	/* a+ == aa* */
+#define	QUEST		0207	/* a? == a|nothing, i.e. 0 or 1 a's */
+#define	ANY		0300	/* Any character except newline, . */
+#define	ANYNL		0301	/* Any character including newline, . */
+#define	NOP		0302	/* No operation, internal use only */
+#define	BOL		0303	/* Beginning of line, ^ */
+#define	EOL		0304	/* End of line, $ */
+#define	CCLASS		0305	/* Character class, [] */
+#define	NCCLASS		0306	/* Negated character class, [] */
+#define	END		0377	/* Terminate: match found */
+
+/*
+ *  regexec execution lists
+ */
+#define LISTINCREMENT 8
+typedef struct Relist	Relist;
+struct Relist
+{
+	Reinst		*inst;		/* Reinstruction of the thread */
+	Resublist	se;		/* matched subexpressions in this thread */
+};
+extern Relist*	_relist[2];
+extern Relist*	_reliste[2];
+extern int	_relistsize;
+
+extern Relist*	_renewthread(Relist*, Reinst*, Resublist*);
+extern void	_renewmatch(Resub*, int, Resublist*);
diff --git a/sys/src/ape/lib/regexp/regerror.c b/sys/src/ape/lib/regexp/regerror.c
new file mode 100755
index 000000000..bfa158299
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regerror.c
@@ -0,0 +1,16 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "regexp.h"
+
+void
+regerror(char *s)
+{
+	char buf[132];
+
+	strcpy(buf, "regerror: ");
+	strcat(buf, s);
+	strcat(buf, "\n");
+	fwrite(buf, 1, strlen(buf), stderr);
+	exit(1);
+}
diff --git a/sys/src/ape/lib/regexp/regexec.c b/sys/src/ape/lib/regexp/regexec.c
new file mode 100755
index 000000000..dee888b09
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regexec.c
@@ -0,0 +1,191 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "regexp.h"
+#include "regcomp.h"
+
+static Resublist sempty;		/* empty set of matches */
+
+/*
+ *  return	0 if no match
+ *		>0 if a match
+ *		<0 if we ran out of _relist space
+ */
+static int
+regexec1(Reprog *progp,	/* program to run */
+	char *bol,	/* string to run machine on */
+	Resub *mp,	/* subexpression elements */
+	int ms,		/* number of elements at mp */
+	char *starts,
+	char *eol,
+	wchar_t startchar)
+{
+	int flag=0;
+	Reinst *inst;
+	Relist *tlp;
+	char *s;
+	int i, checkstart;
+	wchar_t r, *rp, *ep;
+	int n;
+	Relist* tl;		/* This list, next list */
+	Relist* nl;
+	Relist* tle;		/* ends of this and next list */
+	Relist* nle;
+	int match;
+
+	match = 0;
+	checkstart = startchar;
+	sempty.m[0].s.sp = 0;
+	if(mp!=0)
+		for(i=0; i<ms; i++)
+			mp[i].s.sp = mp[i].e.ep = 0;
+	_relist[0][0].inst = _relist[1][0].inst = 0;
+
+	/* Execute machine once for each character, including terminal NUL */
+	s = starts;
+	do{
+		/* fast check for first char */
+		r = *(unsigned char*)s;
+		if(checkstart && r != startchar){
+			s++;
+			continue;
+		}
+
+		if(r < Runeself)
+			n = 1;
+		else {
+			n = mbtowc(&r, s, MB_CUR_MAX);
+			if (n <= 0)
+				n = 1;
+		}
+
+		/* switch run lists */
+		tl = _relist[flag];
+		tle = _reliste[flag];
+		nl = _relist[flag^=1];
+		nle = _reliste[flag];
+		nl->inst = 0;
+
+		/* Add first instruction to current list */
+		if(match == 0){
+			sempty.m[0].s.sp = s;
+			_renewthread(tl, progp->startinst, &sempty);
+		}
+
+		/* Execute machine until current list is empty */
+		for(tlp=tl; tlp->inst; tlp++){	/* assignment = */
+			if(s == eol)
+				break;
+
+			for(inst = tlp->inst; ; inst = inst->l.next){
+				switch(inst->type){
+				case RUNE:	/* regular character */
+					if(inst->r.r == r)
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case LBRA:
+					tlp->se.m[inst->r.subid].s.sp = s;
+					continue;
+				case RBRA:
+					tlp->se.m[inst->r.subid].e.ep = s;
+					continue;
+				case ANY:
+					if(r != '\n')
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case ANYNL:
+					if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+						return -1;
+					break;
+				case BOL:
+					if(s == bol || *(s-1) == '\n')
+						continue;
+					break;
+				case EOL:
+					if(r == 0 || r == '\n')
+						continue;
+					break;
+				case CCLASS:
+					ep = inst->r.cp->end;
+					for(rp = inst->r.cp->spans; rp < ep; rp += 2)
+						if(r >= rp[0] && r <= rp[1]){
+							if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+								return -1;
+							break;
+						}
+					break;
+				case NCCLASS:
+					ep = inst->r.cp->end;
+					for(rp = inst->r.cp->spans; rp < ep; rp += 2)
+						if(r >= rp[0] && r <= rp[1])
+							break;
+					if(rp == ep)
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case OR:
+					/* evaluate right choice later */
+					if(_renewthread(tlp, inst->r.right, &tlp->se) == tle)
+						return -1;
+					/* efficiency: advance and re-evaluate */
+					continue;
+				case END:	/* Match! */
+					match = 1;
+					tlp->se.m[0].e.ep = s;
+					if(mp != 0)
+						_renewmatch(mp, ms, &tlp->se);
+					break;
+				}
+				break;
+			}
+		}
+		checkstart = startchar && nl->inst==0;
+		s += n;
+	}while(r);
+	return match;
+}
+
+extern int
+regexec(Reprog *progp,	/* program to run */
+	char *bol,	/* string to run machine on */
+	Resub *mp,	/* subexpression elements */
+	int ms)		/* number of elements at mp */
+{
+	char *starts;	/* where to start match */
+	char *eol;	/* where to end match */
+	wchar_t startchar;
+	int rv;
+
+	/*
+ 	 *  use user-specified starting/ending location if specified
+	 */
+	starts = bol;
+	eol = 0;
+	if(mp && ms>0){
+		if(mp->s.sp)
+			starts = mp->s.sp;
+		if(mp->e.ep)
+			eol = mp->e.ep;
+	}
+	startchar = (progp->startinst->type == RUNE && progp->startinst->r.r < Runeself)
+		? progp->startinst->r.r : 0;
+
+	/* keep trying till we have enough list space to terminate */
+	for(;;){
+		if(_relist[0] == 0){
+			_relist[0] = malloc(2*_relistsize*sizeof(Relist));
+			_relist[1] = _relist[0] + _relistsize;
+			_reliste[0] = _relist[0] + _relistsize - 1;
+			_reliste[1] = _relist[1] + _relistsize - 1;
+			if(_relist[0] == 0)
+				regerror("_relist overflow");
+		}
+		rv = regexec1(progp, bol, mp, ms, starts, eol, startchar);
+		if(rv >= 0)
+			return rv;
+		free(_relist[0]);
+		_relist[0] = 0;
+		_relistsize += LISTINCREMENT;
+	}
+}
diff --git a/sys/src/ape/lib/regexp/regsub.c b/sys/src/ape/lib/regexp/regsub.c
new file mode 100755
index 000000000..0c891e9c6
--- /dev/null
+++ b/sys/src/ape/lib/regexp/regsub.c
@@ -0,0 +1,64 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "regexp.h"
+
+/* substitute into one string using the matches from the last regexec() */
+extern	void
+regsub(char *sp,	/* source string */
+	char *dp,	/* destination string */
+	int dlen,
+	Resub *mp,	/* subexpression elements */
+	int ms)		/* number of elements pointed to by mp */
+{
+	char *ssp, *ep;
+	int i;
+
+	ep = dp+dlen-1;
+	while(*sp != '\0'){
+		if(*sp == '\\'){
+			switch(*++sp){
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				i = *sp-'0';
+				if(mp[i].s.sp != 0 && mp!=0 && ms>i)
+					for(ssp = mp[i].s.sp;
+					     ssp < mp[i].e.ep;
+					     ssp++)
+						if(dp < ep)
+							*dp++ = *ssp;
+				break;
+			case '\\':
+				if(dp < ep)
+					*dp++ = '\\';
+				break;
+			case '\0':
+				sp--;
+				break;
+			default:
+				if(dp < ep)
+					*dp++ = *sp;
+				break;
+			}
+		}else if(*sp == '&'){				
+			if(mp[0].s.sp != 0 && mp!=0 && ms>0)
+			if(mp[0].s.sp != 0)
+				for(ssp = mp[0].s.sp;
+				     ssp < mp[0].e.ep; ssp++)
+					if(dp < ep)
+						*dp++ = *ssp;
+		}else{
+			if(dp < ep)
+				*dp++ = *sp;
+		}
+		sp++;
+	}
+	*dp = '\0';
+}
diff --git a/sys/src/ape/lib/regexp/rregexec.c b/sys/src/ape/lib/regexp/rregexec.c
new file mode 100755
index 000000000..519ac25ad
--- /dev/null
+++ b/sys/src/ape/lib/regexp/rregexec.c
@@ -0,0 +1,181 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "regexp.h"
+#include "regcomp.h"
+
+static Resublist sempty;		/* empty set of matches */
+
+/*
+ *  return	0 if no match
+ *		>0 if a match
+ *		<0 if we ran out of _relist space
+ */
+static int
+rregexec1(Reprog *progp,	/* program to run */
+	wchar_t *bol,		/* string to run machine on */
+	Resub *mp,		/* subexpression elements */
+	int ms,			/* number of elements at mp */
+	wchar_t *starts,
+	wchar_t *eol,
+	wchar_t startchar)
+{
+	int flag=0;
+	Reinst *inst;
+	Relist *tlp;
+	wchar_t *s;
+	int i, checkstart;
+	wchar_t r, *rp, *ep;
+	int n;
+	Relist* tl;		/* This list, next list */
+	Relist* nl;
+	Relist* tle;		/* ends of this and next list */
+	Relist* nle;
+	int match;
+
+	match = 0;
+	checkstart = startchar;
+	sempty.m[0].s.rsp = 0;
+	if(mp!=0)
+		for(i=0; i<ms; i++)
+			mp[i].s.rsp = mp[i].e.rep = 0;
+	_relist[0][0].inst = _relist[1][0].inst = 0;
+
+	/* Execute machine once for each character, including terminal NUL */
+	s = starts;
+	do{
+		r = *s;
+
+		/* fast check for first char */
+		if(checkstart && r!=startchar){
+			s++;
+			continue;
+		}
+
+		/* switch run lists */
+		tl = _relist[flag];
+		tle = _reliste[flag];
+		nl = _relist[flag^=1];
+		nle = _reliste[flag];
+		nl->inst = 0;
+
+		/* Add first instruction to current list */
+		sempty.m[0].s.rsp = s;
+		_renewthread(tl, progp->startinst, &sempty);
+
+		/* Execute machine until current list is empty */
+		for(tlp=tl; tlp->inst; tlp++){	/* assignment = */
+			if(s == eol)
+				break;
+
+			for(inst=tlp->inst; ; inst = inst->l.next){
+				switch(inst->type){
+				case RUNE:	/* regular character */
+					if(inst->r.r == r)
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case LBRA:
+					tlp->se.m[inst->r.subid].s.rsp = s;
+					continue;
+				case RBRA:
+					tlp->se.m[inst->r.subid].e.rep = s;
+					continue;
+				case ANY:
+					if(r != '\n')
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case ANYNL:
+					if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case BOL:
+					if(s == bol || *(s-1) == '\n')
+						continue;
+					break;
+				case EOL:
+					if(r == 0 || r == '\n')
+						continue;
+					break;
+				case CCLASS:
+					ep = inst->r.cp->end;
+					for(rp = inst->r.cp->spans; rp < ep; rp += 2)
+						if(r >= rp[0] && r <= rp[1]){
+							if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+								return -1;
+							break;
+						}
+					break;
+				case NCCLASS:
+					ep = inst->r.cp->end;
+					for(rp = inst->r.cp->spans; rp < ep; rp += 2)
+						if(r >= rp[0] && r <= rp[1])
+							break;
+					if(rp == ep)
+						if(_renewthread(nl, inst->l.next, &tlp->se)==nle)
+							return -1;
+					break;
+				case OR:
+					/* evaluate right choice later */
+					if(_renewthread(tlp, inst->r.right, &tlp->se) == tle)
+						return -1;
+					/* efficiency: advance and re-evaluate */
+					continue;
+				case END:	/* Match! */
+					match = 1;
+					tlp->se.m[0].e.rep = s;
+					if(mp != 0)
+						_renewmatch(mp, ms, &tlp->se);
+					break;
+				}
+				break;
+			}
+		}
+		checkstart = startchar && nl->inst==0;
+		s++;
+	}while(r);
+	return match;
+}
+
+extern int
+rregexec(Reprog *progp,	/* program to run */
+	wchar_t *bol,	/* string to run machine on */
+	Resub *mp,	/* subexpression elements */
+	int ms)		/* number of elements at mp */
+{
+	wchar_t *starts;	/* where to start match */
+	wchar_t *eol;	/* where to end match */
+	wchar_t startchar;
+	int rv;
+
+	/*
+ 	 *  use user-specified starting/ending location if specified
+	 */
+	starts = bol;
+	eol = 0;
+	if(mp && ms>0){
+		if(mp->s.rsp)
+			starts = mp->s.rsp;
+		if(mp->e.rep)
+			eol = mp->e.rep;
+	}
+	startchar = progp->startinst->type == RUNE ? progp->startinst->r.r : 0;
+
+	/* keep trying till we have enough list space to terminate */
+	for(;;){
+		if(_relist[0] == 0){
+			_relist[0] = malloc(2*_relistsize*sizeof(Relist));
+			_relist[1] = _relist[0] + _relistsize;
+			_reliste[0] = _relist[0] + _relistsize - 1;
+			_reliste[1] = _relist[1] + _relistsize - 1;
+			if(_relist[0] == 0)
+				regerror("_relist overflow");
+		}
+		rv = rregexec1(progp, bol, mp, ms, starts, eol, startchar);
+		if(rv >= 0)
+			return rv;
+		free(_relist[0]);
+		_relist[0] = 0;
+		_relistsize += LISTINCREMENT;
+	}
+}
diff --git a/sys/src/ape/lib/regexp/rregsub.c b/sys/src/ape/lib/regexp/rregsub.c
new file mode 100755
index 000000000..5fc3e5960
--- /dev/null
+++ b/sys/src/ape/lib/regexp/rregsub.c
@@ -0,0 +1,64 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "regexp.h"
+
+/* substitute into one string using the matches from the last regexec() */
+extern	void
+rregsub(wchar_t *sp,	/* source string */
+	wchar_t *dp,	/* destination string */
+	int dlen,
+	Resub *mp,	/* subexpression elements */
+	int ms)		/* number of elements pointed to by mp */
+{
+	wchar_t *ssp, *ep;
+	int i;
+
+	ep = dp+(dlen/sizeof(wchar_t))-1;
+	while(*sp != '\0'){
+		if(*sp == '\\'){
+			switch(*++sp){
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				i = *sp-'0';
+				if(mp[i].s.rsp != 0 && mp!=0 && ms>i)
+					for(ssp = mp[i].s.rsp;
+					     ssp < mp[i].e.rep;
+					     ssp++)
+						if(dp < ep)
+							*dp++ = *ssp;
+				break;
+			case '\\':
+				if(dp < ep)
+					*dp++ = '\\';
+				break;
+			case '\0':
+				sp--;
+				break;
+			default:
+				if(dp < ep)
+					*dp++ = *sp;
+				break;
+			}
+		}else if(*sp == '&'){				
+			if(mp[0].s.rsp != 0 && mp!=0 && ms>0)
+			if(mp[0].s.rsp != 0)
+				for(ssp = mp[0].s.rsp;
+				     ssp < mp[0].e.rep; ssp++)
+					if(dp < ep)
+						*dp++ = *ssp;
+		}else{
+			if(dp < ep)
+				*dp++ = *sp;
+		}
+		sp++;
+	}
+	*dp = '\0';
+}
diff --git a/sys/src/ape/lib/utf/lib9.h b/sys/src/ape/lib/utf/lib9.h
new file mode 100755
index 000000000..e6128ae4d
--- /dev/null
+++ b/sys/src/ape/lib/utf/lib9.h
@@ -0,0 +1,17 @@
+#include <string.h>
+#include "utf.h"
+
+#define nil ((void*)0)
+
+#define uchar _fmtuchar
+#define ushort _fmtushort
+#define uint _fmtuint
+#define ulong _fmtulong
+#define vlong _fmtvlong
+#define uvlong _fmtuvlong
+
+typedef unsigned char		uchar;
+typedef unsigned short		ushort;
+typedef unsigned int		uint;
+typedef unsigned long		ulong;
+
diff --git a/sys/src/ape/lib/utf/mkfile b/sys/src/ape/lib/utf/mkfile
new file mode 100755
index 000000000..8cbca19cd
--- /dev/null
+++ b/sys/src/ape/lib/utf/mkfile
@@ -0,0 +1,37 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libutf.a
+
+OFILES=\
+	rune.$O\
+	runestrcat.$O\
+	runestrchr.$O\
+	runestrcmp.$O\
+	runestrcpy.$O\
+	runestrdup.$O\
+	runestrlen.$O\
+	runestrecpy.$O\
+	runestrncat.$O\
+	runestrncmp.$O\
+	runestrncpy.$O\
+	runestrrchr.$O\
+	runestrstr.$O\
+	runetype.$O\
+	utfecpy.$O\
+	utflen.$O\
+	utfnlen.$O\
+	utfrrune.$O\
+	utfrune.$O\
+	utfutf.$O\
+
+HFILES=\
+	/sys/include/ape/utf.h\
+
+UPDATE=\
+	mkfile\
+	${OFILES:%.$O=%.c}\
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c -D_POSIX_SOURCE -D_PLAN9_SOURCE -D_BSD_EXTENSION
diff --git a/sys/src/ape/lib/utf/rune.c b/sys/src/ape/lib/utf/rune.c
new file mode 100755
index 000000000..e1aaa9be9
--- /dev/null
+++ b/sys/src/ape/lib/utf/rune.c
@@ -0,0 +1,177 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+enum
+{
+	Bit1	= 7,
+	Bitx	= 6,
+	Bit2	= 5,
+	Bit3	= 4,
+	Bit4	= 3,
+
+	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
+	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
+	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
+	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
+	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
+
+	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
+	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
+	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
+
+	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
+	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
+
+	Bad	= Runeerror,
+};
+
+int
+chartorune(Rune *rune, char *str)
+{
+	int c, c1, c2;
+	long l;
+
+	/*
+	 * one character sequence
+	 *	00000-0007F => T1
+	 */
+	c = *(uchar*)str;
+	if(c < Tx) {
+		*rune = c;
+		return 1;
+	}
+
+	/*
+	 * two character sequence
+	 *	0080-07FF => T2 Tx
+	 */
+	c1 = *(uchar*)(str+1) ^ Tx;
+	if(c1 & Testx)
+		goto bad;
+	if(c < T3) {
+		if(c < T2)
+			goto bad;
+		l = ((c << Bitx) | c1) & Rune2;
+		if(l <= Rune1)
+			goto bad;
+		*rune = l;
+		return 2;
+	}
+
+	/*
+	 * three character sequence
+	 *	0800-FFFF => T3 Tx Tx
+	 */
+	c2 = *(uchar*)(str+2) ^ Tx;
+	if(c2 & Testx)
+		goto bad;
+	if(c < T4) {
+		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
+		if(l <= Rune2)
+			goto bad;
+		*rune = l;
+		return 3;
+	}
+
+	/*
+	 * bad decoding
+	 */
+bad:
+	*rune = Bad;
+	return 1;
+}
+
+int
+runetochar(char *str, Rune *rune)
+{
+	long c;
+
+	/*
+	 * one character sequence
+	 *	00000-0007F => 00-7F
+	 */
+	c = *rune;
+	if(c <= Rune1) {
+		str[0] = c;
+		return 1;
+	}
+
+	/*
+	 * two character sequence
+	 *	0080-07FF => T2 Tx
+	 */
+	if(c <= Rune2) {
+		str[0] = T2 | (c >> 1*Bitx);
+		str[1] = Tx | (c & Maskx);
+		return 2;
+	}
+
+	/*
+	 * three character sequence
+	 *	0800-FFFF => T3 Tx Tx
+	 */
+	str[0] = T3 |  (c >> 2*Bitx);
+	str[1] = Tx | ((c >> 1*Bitx) & Maskx);
+	str[2] = Tx |  (c & Maskx);
+	return 3;
+}
+
+int
+runelen(long c)
+{
+	Rune rune;
+	char str[10];
+
+	rune = c;
+	return runetochar(str, &rune);
+}
+
+int
+runenlen(Rune *r, int nrune)
+{
+	int nb, c;
+
+	nb = 0;
+	while(nrune--) {
+		c = *r++;
+		if(c <= Rune1)
+			nb++;
+		else
+		if(c <= Rune2)
+			nb += 2;
+		else
+			nb += 3;
+	}
+	return nb;
+}
+
+int
+fullrune(char *str, int n)
+{
+	int c;
+
+	if(n > 0) {
+		c = *(uchar*)str;
+		if(c < Tx)
+			return 1;
+		if(n > 1)
+			if(c < T3 || n > 2)
+				return 1;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/utf/runestrcat.c b/sys/src/ape/lib/utf/runestrcat.c
new file mode 100755
index 000000000..e1e8c9d57
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrcat.c
@@ -0,0 +1,25 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrcat(Rune *s1, Rune *s2)
+{
+
+	runestrcpy(runestrchr(s1, 0), s2);
+	return s1;
+}
diff --git a/sys/src/ape/lib/utf/runestrchr.c b/sys/src/ape/lib/utf/runestrchr.c
new file mode 100755
index 000000000..45ee673a5
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrchr.c
@@ -0,0 +1,35 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrchr(Rune *s, Rune c)
+{
+	Rune c0 = c;
+	Rune c1;
+
+	if(c == 0) {
+		while(*s++)
+			;
+		return s-1;
+	}
+
+	while(c1 = *s++)
+		if(c1 == c0)
+			return s-1;
+	return 0;
+}
diff --git a/sys/src/ape/lib/utf/runestrcmp.c b/sys/src/ape/lib/utf/runestrcmp.c
new file mode 100755
index 000000000..d14145f38
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrcmp.c
@@ -0,0 +1,35 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+int
+runestrcmp(Rune *s1, Rune *s2)
+{
+	Rune c1, c2;
+
+	for(;;) {
+		c1 = *s1++;
+		c2 = *s2++;
+		if(c1 != c2) {
+			if(c1 > c2)
+				return 1;
+			return -1;
+		}
+		if(c1 == 0)
+			return 0;
+	}
+}
diff --git a/sys/src/ape/lib/utf/runestrcpy.c b/sys/src/ape/lib/utf/runestrcpy.c
new file mode 100755
index 000000000..9d7aa026a
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrcpy.c
@@ -0,0 +1,28 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrcpy(Rune *s1, Rune *s2)
+{
+	Rune *os1;
+
+	os1 = s1;
+	while(*s1++ = *s2++)
+		;
+	return os1;
+}
diff --git a/sys/src/ape/lib/utf/runestrdup.c b/sys/src/ape/lib/utf/runestrdup.c
new file mode 100755
index 000000000..97a889c8f
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrdup.c
@@ -0,0 +1,30 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrdup(Rune *s) 
+{  
+	Rune *ns;
+
+	ns = malloc(sizeof(Rune)*(runestrlen(s) + 1));
+	if(ns == 0)
+		return 0;
+
+	return runestrcpy(ns, s);
+}
diff --git a/sys/src/ape/lib/utf/runestrecpy.c b/sys/src/ape/lib/utf/runestrecpy.c
new file mode 100755
index 000000000..f3e4a096b
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrecpy.c
@@ -0,0 +1,32 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrecpy(Rune *s1, Rune *es1, Rune *s2)
+{
+	if(s1 >= es1)
+		return s1;
+
+	while(*s1++ = *s2++){
+		if(s1 == es1){
+			*--s1 = '\0';
+			break;
+		}
+	}
+	return s1;
+}
diff --git a/sys/src/ape/lib/utf/runestrlen.c b/sys/src/ape/lib/utf/runestrlen.c
new file mode 100755
index 000000000..bca3050c5
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrlen.c
@@ -0,0 +1,24 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+long
+runestrlen(Rune *s)
+{
+
+	return runestrchr(s, 0) - s;
+}
diff --git a/sys/src/ape/lib/utf/runestrncat.c b/sys/src/ape/lib/utf/runestrncat.c
new file mode 100755
index 000000000..74400c30e
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrncat.c
@@ -0,0 +1,32 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrncat(Rune *s1, Rune *s2, long n)
+{
+	Rune *os1;
+
+	os1 = s1;
+	s1 = runestrchr(s1, 0);
+	while(*s1++ = *s2++)
+		if(--n < 0) {
+			s1[-1] = 0;
+			break;
+		}
+	return os1;
+}
diff --git a/sys/src/ape/lib/utf/runestrncmp.c b/sys/src/ape/lib/utf/runestrncmp.c
new file mode 100755
index 000000000..dbd9da45c
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrncmp.c
@@ -0,0 +1,37 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+int
+runestrncmp(Rune *s1, Rune *s2, long n)
+{
+	Rune c1, c2;
+
+	while(n > 0) {
+		c1 = *s1++;
+		c2 = *s2++;
+		n--;
+		if(c1 != c2) {
+			if(c1 > c2)
+				return 1;
+			return -1;
+		}
+		if(c1 == 0)
+			break;
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/utf/runestrncpy.c b/sys/src/ape/lib/utf/runestrncpy.c
new file mode 100755
index 000000000..acba7bc2b
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrncpy.c
@@ -0,0 +1,33 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrncpy(Rune *s1, Rune *s2, long n)
+{
+	int i;
+	Rune *os1;
+
+	os1 = s1;
+	for(i = 0; i < n; i++)
+		if((*s1++ = *s2++) == 0) {
+			while(++i < n)
+				*s1++ = 0;
+			return os1;
+		}
+	return os1;
+}
diff --git a/sys/src/ape/lib/utf/runestrrchr.c b/sys/src/ape/lib/utf/runestrrchr.c
new file mode 100755
index 000000000..1f40c5a65
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrrchr.c
@@ -0,0 +1,30 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+Rune*
+runestrrchr(Rune *s, Rune c)
+{
+	Rune *r;
+
+	if(c == 0)
+		return runestrchr(s, 0);
+	r = 0;
+	while(s = runestrchr(s, c))
+		r = s++;
+	return r;
+}
diff --git a/sys/src/ape/lib/utf/runestrstr.c b/sys/src/ape/lib/utf/runestrstr.c
new file mode 100755
index 000000000..48583a3d5
--- /dev/null
+++ b/sys/src/ape/lib/utf/runestrstr.c
@@ -0,0 +1,44 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+/*
+ * Return pointer to first occurrence of s2 in s1,
+ * 0 if none
+ */
+Rune*
+runestrstr(Rune *s1, Rune *s2)
+{
+	Rune *p, *pa, *pb;
+	int c0, c;
+
+	c0 = *s2;
+	if(c0 == 0)
+		return s1;
+	s2++;
+	for(p=runestrchr(s1, c0); p; p=runestrchr(p+1, c0)) {
+		pa = p;
+		for(pb=s2;; pb++) {
+			c = *pb;
+			if(c == 0)
+				return p;
+			if(c != *++pa)
+				break;
+		}
+	}
+	return 0;
+}
diff --git a/sys/src/ape/lib/utf/runetype.c b/sys/src/ape/lib/utf/runetype.c
new file mode 100755
index 000000000..ffae30e69
--- /dev/null
+++ b/sys/src/ape/lib/utf/runetype.c
@@ -0,0 +1,1152 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+/*
+ * alpha ranges -
+ *	only covers ranges not in lower||upper
+ */
+static
+Rune	__alpha2[] =
+{
+	0x00d8,	0x00f6,	/* Ø - ö */
+	0x00f8,	0x01f5,	/* ø - ǵ */
+	0x0250,	0x02a8,	/* ɐ - ʨ */
+	0x038e,	0x03a1,	/* Ύ - Ρ */
+	0x03a3,	0x03ce,	/* Σ - ώ */
+	0x03d0,	0x03d6,	/* ϐ - ϖ */
+	0x03e2,	0x03f3,	/* Ϣ - ϳ */
+	0x0490,	0x04c4,	/* Ґ - ӄ */
+	0x0561,	0x0587,	/* ա - և */
+	0x05d0,	0x05ea,	/* א - ת */
+	0x05f0,	0x05f2,	/* װ - ײ */
+	0x0621,	0x063a,	/* ء - غ */
+	0x0640,	0x064a,	/* ـ - ي */
+	0x0671,	0x06b7,	/* ٱ - ڷ */
+	0x06ba,	0x06be,	/* ں - ھ */
+	0x06c0,	0x06ce,	/* ۀ - ێ */
+	0x06d0,	0x06d3,	/* ې - ۓ */
+	0x0905,	0x0939,	/* अ - ह */
+	0x0958,	0x0961,	/* क़ - ॡ */
+	0x0985,	0x098c,	/* অ - ঌ */
+	0x098f,	0x0990,	/* এ - ঐ */
+	0x0993,	0x09a8,	/* ও - ন */
+	0x09aa,	0x09b0,	/* প - র */
+	0x09b6,	0x09b9,	/* শ - হ */
+	0x09dc,	0x09dd,	/* ড় - ঢ় */
+	0x09df,	0x09e1,	/* য় - ৡ */
+	0x09f0,	0x09f1,	/* ৰ - ৱ */
+	0x0a05,	0x0a0a,	/* ਅ - ਊ */
+	0x0a0f,	0x0a10,	/* ਏ - ਐ */
+	0x0a13,	0x0a28,	/* ਓ - ਨ */
+	0x0a2a,	0x0a30,	/* ਪ - ਰ */
+	0x0a32,	0x0a33,	/* ਲ - ਲ਼ */
+	0x0a35,	0x0a36,	/* ਵ - ਸ਼ */
+	0x0a38,	0x0a39,	/* ਸ - ਹ */
+	0x0a59,	0x0a5c,	/* ਖ਼ - ੜ */
+	0x0a85,	0x0a8b,	/* અ - ઋ */
+	0x0a8f,	0x0a91,	/* એ - ઑ */
+	0x0a93,	0x0aa8,	/* ઓ - ન */
+	0x0aaa,	0x0ab0,	/* પ - ર */
+	0x0ab2,	0x0ab3,	/* લ - ળ */
+	0x0ab5,	0x0ab9,	/* વ - હ */
+	0x0b05,	0x0b0c,	/* ଅ - ଌ */
+	0x0b0f,	0x0b10,	/* ଏ - ଐ */
+	0x0b13,	0x0b28,	/* ଓ - ନ */
+	0x0b2a,	0x0b30,	/* ପ - ର */
+	0x0b32,	0x0b33,	/* ଲ - ଳ */
+	0x0b36,	0x0b39,	/* ଶ - ହ */
+	0x0b5c,	0x0b5d,	/* ଡ଼ - ଢ଼ */
+	0x0b5f,	0x0b61,	/* ୟ - ୡ */
+	0x0b85,	0x0b8a,	/* அ - ஊ */
+	0x0b8e,	0x0b90,	/* எ - ஐ */
+	0x0b92,	0x0b95,	/* ஒ - க */
+	0x0b99,	0x0b9a,	/* ங - ச */
+	0x0b9e,	0x0b9f,	/* ஞ - ட */
+	0x0ba3,	0x0ba4,	/* ண - த */
+	0x0ba8,	0x0baa,	/* ந - ப */
+	0x0bae,	0x0bb5,	/* ம - வ */
+	0x0bb7,	0x0bb9,	/* ஷ - ஹ */
+	0x0c05,	0x0c0c,	/* అ - ఌ */
+	0x0c0e,	0x0c10,	/* ఎ - ఐ */
+	0x0c12,	0x0c28,	/* ఒ - న */
+	0x0c2a,	0x0c33,	/* ప - ళ */
+	0x0c35,	0x0c39,	/* వ - హ */
+	0x0c60,	0x0c61,	/* ౠ - ౡ */
+	0x0c85,	0x0c8c,	/* ಅ - ಌ */
+	0x0c8e,	0x0c90,	/* ಎ - ಐ */
+	0x0c92,	0x0ca8,	/* ಒ - ನ */
+	0x0caa,	0x0cb3,	/* ಪ - ಳ */
+	0x0cb5,	0x0cb9,	/* ವ - ಹ */
+	0x0ce0,	0x0ce1,	/* ೠ - ೡ */
+	0x0d05,	0x0d0c,	/* അ - ഌ */
+	0x0d0e,	0x0d10,	/* എ - ഐ */
+	0x0d12,	0x0d28,	/* ഒ - ന */
+	0x0d2a,	0x0d39,	/* പ - ഹ */
+	0x0d60,	0x0d61,	/* ൠ - ൡ */
+	0x0e01,	0x0e30,	/* ก - ะ */
+	0x0e32,	0x0e33,	/* า - ำ */
+	0x0e40,	0x0e46,	/* เ - ๆ */
+	0x0e5a,	0x0e5b,	/* ๚ - ๛ */
+	0x0e81,	0x0e82,	/* ກ - ຂ */
+	0x0e87,	0x0e88,	/* ງ - ຈ */
+	0x0e94,	0x0e97,	/* ດ - ທ */
+	0x0e99,	0x0e9f,	/* ນ - ຟ */
+	0x0ea1,	0x0ea3,	/* ມ - ຣ */
+	0x0eaa,	0x0eab,	/* ສ - ຫ */
+	0x0ead,	0x0eae,	/* ອ - ຮ */
+	0x0eb2,	0x0eb3,	/* າ - ຳ */
+	0x0ec0,	0x0ec4,	/* ເ - ໄ */
+	0x0edc,	0x0edd,	/* ໜ - ໝ */
+	0x0f18,	0x0f19,	/* ༘ - ༙ */
+	0x0f40,	0x0f47,	/* ཀ - ཇ */
+	0x0f49,	0x0f69,	/* ཉ - ཀྵ */
+	0x10d0,	0x10f6,	/* ა - ჶ */
+	0x1100,	0x1159,	/* ᄀ - ᅙ */
+	0x115f,	0x11a2,	/* ᅟ - ᆢ */
+	0x11a8,	0x11f9,	/* ᆨ - ᇹ */
+	0x1e00,	0x1e9b,	/* Ḁ - ẛ */
+	0x1f50,	0x1f57,	/* ὐ - ὗ */
+	0x1f80,	0x1fb4,	/* ᾀ - ᾴ */
+	0x1fb6,	0x1fbc,	/* ᾶ - ᾼ */
+	0x1fc2,	0x1fc4,	/* ῂ - ῄ */
+	0x1fc6,	0x1fcc,	/* ῆ - ῌ */
+	0x1fd0,	0x1fd3,	/* ῐ - ΐ */
+	0x1fd6,	0x1fdb,	/* ῖ - Ί */
+	0x1fe0,	0x1fec,	/* ῠ - Ῥ */
+	0x1ff2,	0x1ff4,	/* ῲ - ῴ */
+	0x1ff6,	0x1ffc,	/* ῶ - ῼ */
+	0x210a,	0x2113,	/* ℊ - ℓ */
+	0x2115,	0x211d,	/* ℕ - ℝ */
+	0x2120,	0x2122,	/* ℠ - ™ */
+	0x212a,	0x2131,	/* K - ℱ */
+	0x2133,	0x2138,	/* ℳ - ℸ */
+	0x3041,	0x3094,	/* ぁ - ゔ */
+	0x30a1,	0x30fa,	/* ァ - ヺ */
+	0x3105,	0x312c,	/* ㄅ - ㄬ */
+	0x3131,	0x318e,	/* ㄱ - ㆎ */
+	0x3192,	0x319f,	/* ㆒ - ㆟ */
+	0x3260,	0x327b,	/* ㉠ - ㉻ */
+	0x328a,	0x32b0,	/* ㊊ - ㊰ */
+	0x32d0,	0x32fe,	/* ㋐ - ㋾ */
+	0x3300,	0x3357,	/* ㌀ - ㍗ */
+	0x3371,	0x3376,	/* ㍱ - ㍶ */
+	0x337b,	0x3394,	/* ㍻ - ㎔ */
+	0x3399,	0x339e,	/* ㎙ - ㎞ */
+	0x33a9,	0x33ad,	/* ㎩ - ㎭ */
+	0x33b0,	0x33c1,	/* ㎰ - ㏁ */
+	0x33c3,	0x33c5,	/* ㏃ - ㏅ */
+	0x33c7,	0x33d7,	/* ㏇ - ㏗ */
+	0x33d9,	0x33dd,	/* ㏙ - ㏝ */
+	0x4e00,	0x9fff,	/* 一 - 鿿 */
+	0xac00,	0xd7a3,	/* 가 - 힣 */
+	0xf900,	0xfb06,	/* 豈 - st */
+	0xfb13,	0xfb17,	/* ﬓ - ﬗ */
+	0xfb1f,	0xfb28,	/* ײַ - ﬨ */
+	0xfb2a,	0xfb36,	/* שׁ - זּ */
+	0xfb38,	0xfb3c,	/* טּ - לּ */
+	0xfb40,	0xfb41,	/* נּ - סּ */
+	0xfb43,	0xfb44,	/* ףּ - פּ */
+	0xfb46,	0xfbb1,	/* צּ - ﮱ */
+	0xfbd3,	0xfd3d,	/* ﯓ - ﴽ */
+	0xfd50,	0xfd8f,	/* ﵐ - ﶏ */
+	0xfd92,	0xfdc7,	/* ﶒ - ﷇ */
+	0xfdf0,	0xfdf9,	/* ﷰ - ﷹ */
+	0xfe70,	0xfe72,	/* ﹰ - ﹲ */
+	0xfe76,	0xfefc,	/* ﹶ - ﻼ */
+	0xff66,	0xff6f,	/* ｦ - ｯ */
+	0xff71,	0xff9d,	/* ｱ - ﾝ */
+	0xffa0,	0xffbe,	/* ﾠ - ﾾ */
+	0xffc2,	0xffc7,	/* ￂ - ￇ */
+	0xffca,	0xffcf,	/* ￊ - ￏ */
+	0xffd2,	0xffd7,	/* ￒ - ￗ */
+	0xffda,	0xffdc,	/* ￚ - ￜ */
+};
+
+/*
+ * alpha singlets -
+ *	only covers ranges not in lower||upper
+ */
+static
+Rune	__alpha1[] =
+{
+	0x00aa,	/* ª */
+	0x00b5,	/* µ */
+	0x00ba,	/* º */
+	0x03da,	/* Ϛ */
+	0x03dc,	/* Ϝ */
+	0x03de,	/* Ϟ */
+	0x03e0,	/* Ϡ */
+	0x06d5,	/* ە */
+	0x09b2,	/* ল */
+	0x0a5e,	/* ਫ਼ */
+	0x0a8d,	/* ઍ */
+	0x0ae0,	/* ૠ */
+	0x0b9c,	/* ஜ */
+	0x0cde,	/* ೞ */
+	0x0e4f,	/* ๏ */
+	0x0e84,	/* ຄ */
+	0x0e8a,	/* ຊ */
+	0x0e8d,	/* ຍ */
+	0x0ea5,	/* ລ */
+	0x0ea7,	/* ວ */
+	0x0eb0,	/* ະ */
+	0x0ebd,	/* ຽ */
+	0x1fbe,	/* ι */
+	0x207f,	/* ⁿ */
+	0x20a8,	/* ₨ */
+	0x2102,	/* ℂ */
+	0x2107,	/* ℇ */
+	0x2124,	/* ℤ */
+	0x2126,	/* Ω */
+	0x2128,	/* ℨ */
+	0xfb3e,	/* מּ */
+	0xfe74,	/* ﹴ */
+};
+
+/*
+ * space ranges
+ */
+static
+Rune	__space2[] =
+{
+	0x0009,	0x000a,	/* tab and newline */
+	0x0020,	0x0020,	/* space */
+	0x00a0,	0x00a0,	/*   */
+	0x2000,	0x200b,	/*   - ​ */
+	0x2028,	0x2029,	/* 
 - 
 */
+	0x3000,	0x3000,	/* 　 */
+	0xfeff,	0xfeff,	/*  */
+};
+
+/*
+ * lower case ranges
+ *	3rd col is conversion excess 500
+ */
+static
+Rune	__toupper2[] =
+{
+	0x0061,	0x007a, 468,	/* a-z A-Z */
+	0x00e0,	0x00f6, 468,	/* à-ö À-Ö */
+	0x00f8,	0x00fe, 468,	/* ø-þ Ø-Þ */
+	0x0256,	0x0257, 295,	/* ɖ-ɗ Ɖ-Ɗ */
+	0x0258,	0x0259, 298,	/* ɘ-ə Ǝ-Ə */
+	0x028a,	0x028b, 283,	/* ʊ-ʋ Ʊ-Ʋ */
+	0x03ad,	0x03af, 463,	/* έ-ί Έ-Ί */
+	0x03b1,	0x03c1, 468,	/* α-ρ Α-Ρ */
+	0x03c3,	0x03cb, 468,	/* σ-ϋ Σ-Ϋ */
+	0x03cd,	0x03ce, 437,	/* ύ-ώ Ύ-Ώ */
+	0x0430,	0x044f, 468,	/* а-я А-Я */
+	0x0451,	0x045c, 420,	/* ё-ќ Ё-Ќ */
+	0x045e,	0x045f, 420,	/* ў-џ Ў-Џ */
+	0x0561,	0x0586, 452,	/* ա-ֆ Ա-Ֆ */
+	0x1f00,	0x1f07, 508,	/* ἀ-ἇ Ἀ-Ἇ */
+	0x1f10,	0x1f15, 508,	/* ἐ-ἕ Ἐ-Ἕ */
+	0x1f20,	0x1f27, 508,	/* ἠ-ἧ Ἠ-Ἧ */
+	0x1f30,	0x1f37, 508,	/* ἰ-ἷ Ἰ-Ἷ */
+	0x1f40,	0x1f45, 508,	/* ὀ-ὅ Ὀ-Ὅ */
+	0x1f60,	0x1f67, 508,	/* ὠ-ὧ Ὠ-Ὧ */
+	0x1f70,	0x1f71, 574,	/* ὰ-ά Ὰ-Ά */
+	0x1f72,	0x1f75, 586,	/* ὲ-ή Ὲ-Ή */
+	0x1f76,	0x1f77, 600,	/* ὶ-ί Ὶ-Ί */
+	0x1f78,	0x1f79, 628,	/* ὸ-ό Ὸ-Ό */
+	0x1f7a,	0x1f7b, 612,	/* ὺ-ύ Ὺ-Ύ */
+	0x1f7c,	0x1f7d, 626,	/* ὼ-ώ Ὼ-Ώ */
+	0x1f80,	0x1f87, 508,	/* ᾀ-ᾇ ᾈ-ᾏ */
+	0x1f90,	0x1f97, 508,	/* ᾐ-ᾗ ᾘ-ᾟ */
+	0x1fa0,	0x1fa7, 508,	/* ᾠ-ᾧ ᾨ-ᾯ */
+	0x1fb0,	0x1fb1, 508,	/* ᾰ-ᾱ Ᾰ-Ᾱ */
+	0x1fd0,	0x1fd1, 508,	/* ῐ-ῑ Ῐ-Ῑ */
+	0x1fe0,	0x1fe1, 508,	/* ῠ-ῡ Ῠ-Ῡ */
+	0x2170,	0x217f, 484,	/* ⅰ-ⅿ Ⅰ-Ⅿ */
+	0x24d0,	0x24e9, 474,	/* ⓐ-ⓩ Ⓐ-Ⓩ */
+	0xff41,	0xff5a, 468,	/* ａ-ｚ Ａ-Ｚ */
+};
+
+/*
+ * lower case singlets
+ *	2nd col is conversion excess 500
+ */
+static
+Rune	__toupper1[] =
+{
+	0x00ff, 621,	/* ÿ Ÿ */
+	0x0101, 499,	/* ā Ā */
+	0x0103, 499,	/* ă Ă */
+	0x0105, 499,	/* ą Ą */
+	0x0107, 499,	/* ć Ć */
+	0x0109, 499,	/* ĉ Ĉ */
+	0x010b, 499,	/* ċ Ċ */
+	0x010d, 499,	/* č Č */
+	0x010f, 499,	/* ď Ď */
+	0x0111, 499,	/* đ Đ */
+	0x0113, 499,	/* ē Ē */
+	0x0115, 499,	/* ĕ Ĕ */
+	0x0117, 499,	/* ė Ė */
+	0x0119, 499,	/* ę Ę */
+	0x011b, 499,	/* ě Ě */
+	0x011d, 499,	/* ĝ Ĝ */
+	0x011f, 499,	/* ğ Ğ */
+	0x0121, 499,	/* ġ Ġ */
+	0x0123, 499,	/* ģ Ģ */
+	0x0125, 499,	/* ĥ Ĥ */
+	0x0127, 499,	/* ħ Ħ */
+	0x0129, 499,	/* ĩ Ĩ */
+	0x012b, 499,	/* ī Ī */
+	0x012d, 499,	/* ĭ Ĭ */
+	0x012f, 499,	/* į Į */
+	0x0131, 268,	/* ı I */
+	0x0133, 499,	/* ij IJ */
+	0x0135, 499,	/* ĵ Ĵ */
+	0x0137, 499,	/* ķ Ķ */
+	0x013a, 499,	/* ĺ Ĺ */
+	0x013c, 499,	/* ļ Ļ */
+	0x013e, 499,	/* ľ Ľ */
+	0x0140, 499,	/* ŀ Ŀ */
+	0x0142, 499,	/* ł Ł */
+	0x0144, 499,	/* ń Ń */
+	0x0146, 499,	/* ņ Ņ */
+	0x0148, 499,	/* ň Ň */
+	0x014b, 499,	/* ŋ Ŋ */
+	0x014d, 499,	/* ō Ō */
+	0x014f, 499,	/* ŏ Ŏ */
+	0x0151, 499,	/* ő Ő */
+	0x0153, 499,	/* œ Œ */
+	0x0155, 499,	/* ŕ Ŕ */
+	0x0157, 499,	/* ŗ Ŗ */
+	0x0159, 499,	/* ř Ř */
+	0x015b, 499,	/* ś Ś */
+	0x015d, 499,	/* ŝ Ŝ */
+	0x015f, 499,	/* ş Ş */
+	0x0161, 499,	/* š Š */
+	0x0163, 499,	/* ţ Ţ */
+	0x0165, 499,	/* ť Ť */
+	0x0167, 499,	/* ŧ Ŧ */
+	0x0169, 499,	/* ũ Ũ */
+	0x016b, 499,	/* ū Ū */
+	0x016d, 499,	/* ŭ Ŭ */
+	0x016f, 499,	/* ů Ů */
+	0x0171, 499,	/* ű Ű */
+	0x0173, 499,	/* ų Ų */
+	0x0175, 499,	/* ŵ Ŵ */
+	0x0177, 499,	/* ŷ Ŷ */
+	0x017a, 499,	/* ź Ź */
+	0x017c, 499,	/* ż Ż */
+	0x017e, 499,	/* ž Ž */
+	0x017f, 200,	/* ſ S */
+	0x0183, 499,	/* ƃ Ƃ */
+	0x0185, 499,	/* ƅ Ƅ */
+	0x0188, 499,	/* ƈ Ƈ */
+	0x018c, 499,	/* ƌ Ƌ */
+	0x0192, 499,	/* ƒ Ƒ */
+	0x0199, 499,	/* ƙ Ƙ */
+	0x01a1, 499,	/* ơ Ơ */
+	0x01a3, 499,	/* ƣ Ƣ */
+	0x01a5, 499,	/* ƥ Ƥ */
+	0x01a8, 499,	/* ƨ Ƨ */
+	0x01ad, 499,	/* ƭ Ƭ */
+	0x01b0, 499,	/* ư Ư */
+	0x01b4, 499,	/* ƴ Ƴ */
+	0x01b6, 499,	/* ƶ Ƶ */
+	0x01b9, 499,	/* ƹ Ƹ */
+	0x01bd, 499,	/* ƽ Ƽ */
+	0x01c5, 499,	/* Dž DŽ */
+	0x01c6, 498,	/* dž DŽ */
+	0x01c8, 499,	/* Lj LJ */
+	0x01c9, 498,	/* lj LJ */
+	0x01cb, 499,	/* Nj NJ */
+	0x01cc, 498,	/* nj NJ */
+	0x01ce, 499,	/* ǎ Ǎ */
+	0x01d0, 499,	/* ǐ Ǐ */
+	0x01d2, 499,	/* ǒ Ǒ */
+	0x01d4, 499,	/* ǔ Ǔ */
+	0x01d6, 499,	/* ǖ Ǖ */
+	0x01d8, 499,	/* ǘ Ǘ */
+	0x01da, 499,	/* ǚ Ǚ */
+	0x01dc, 499,	/* ǜ Ǜ */
+	0x01df, 499,	/* ǟ Ǟ */
+	0x01e1, 499,	/* ǡ Ǡ */
+	0x01e3, 499,	/* ǣ Ǣ */
+	0x01e5, 499,	/* ǥ Ǥ */
+	0x01e7, 499,	/* ǧ Ǧ */
+	0x01e9, 499,	/* ǩ Ǩ */
+	0x01eb, 499,	/* ǫ Ǫ */
+	0x01ed, 499,	/* ǭ Ǭ */
+	0x01ef, 499,	/* ǯ Ǯ */
+	0x01f2, 499,	/* Dz DZ */
+	0x01f3, 498,	/* dz DZ */
+	0x01f5, 499,	/* ǵ Ǵ */
+	0x01fb, 499,	/* ǻ Ǻ */
+	0x01fd, 499,	/* ǽ Ǽ */
+	0x01ff, 499,	/* ǿ Ǿ */
+	0x0201, 499,	/* ȁ Ȁ */
+	0x0203, 499,	/* ȃ Ȃ */
+	0x0205, 499,	/* ȅ Ȅ */
+	0x0207, 499,	/* ȇ Ȇ */
+	0x0209, 499,	/* ȉ Ȉ */
+	0x020b, 499,	/* ȋ Ȋ */
+	0x020d, 499,	/* ȍ Ȍ */
+	0x020f, 499,	/* ȏ Ȏ */
+	0x0211, 499,	/* ȑ Ȑ */
+	0x0213, 499,	/* ȓ Ȓ */
+	0x0215, 499,	/* ȕ Ȕ */
+	0x0217, 499,	/* ȗ Ȗ */
+	0x0253, 290,	/* ɓ Ɓ */
+	0x0254, 294,	/* ɔ Ɔ */
+	0x025b, 297,	/* ɛ Ɛ */
+	0x0260, 295,	/* ɠ Ɠ */
+	0x0263, 293,	/* ɣ Ɣ */
+	0x0268, 291,	/* ɨ Ɨ */
+	0x0269, 289,	/* ɩ Ɩ */
+	0x026f, 289,	/* ɯ Ɯ */
+	0x0272, 287,	/* ɲ Ɲ */
+	0x0283, 282,	/* ʃ Ʃ */
+	0x0288, 282,	/* ʈ Ʈ */
+	0x0292, 281,	/* ʒ Ʒ */
+	0x03ac, 462,	/* ά Ά */
+	0x03cc, 436,	/* ό Ό */
+	0x03d0, 438,	/* ϐ Β */
+	0x03d1, 443,	/* ϑ Θ */
+	0x03d5, 453,	/* ϕ Φ */
+	0x03d6, 446,	/* ϖ Π */
+	0x03e3, 499,	/* ϣ Ϣ */
+	0x03e5, 499,	/* ϥ Ϥ */
+	0x03e7, 499,	/* ϧ Ϧ */
+	0x03e9, 499,	/* ϩ Ϩ */
+	0x03eb, 499,	/* ϫ Ϫ */
+	0x03ed, 499,	/* ϭ Ϭ */
+	0x03ef, 499,	/* ϯ Ϯ */
+	0x03f0, 414,	/* ϰ Κ */
+	0x03f1, 420,	/* ϱ Ρ */
+	0x0461, 499,	/* ѡ Ѡ */
+	0x0463, 499,	/* ѣ Ѣ */
+	0x0465, 499,	/* ѥ Ѥ */
+	0x0467, 499,	/* ѧ Ѧ */
+	0x0469, 499,	/* ѩ Ѩ */
+	0x046b, 499,	/* ѫ Ѫ */
+	0x046d, 499,	/* ѭ Ѭ */
+	0x046f, 499,	/* ѯ Ѯ */
+	0x0471, 499,	/* ѱ Ѱ */
+	0x0473, 499,	/* ѳ Ѳ */
+	0x0475, 499,	/* ѵ Ѵ */
+	0x0477, 499,	/* ѷ Ѷ */
+	0x0479, 499,	/* ѹ Ѹ */
+	0x047b, 499,	/* ѻ Ѻ */
+	0x047d, 499,	/* ѽ Ѽ */
+	0x047f, 499,	/* ѿ Ѿ */
+	0x0481, 499,	/* ҁ Ҁ */
+	0x0491, 499,	/* ґ Ґ */
+	0x0493, 499,	/* ғ Ғ */
+	0x0495, 499,	/* ҕ Ҕ */
+	0x0497, 499,	/* җ Җ */
+	0x0499, 499,	/* ҙ Ҙ */
+	0x049b, 499,	/* қ Қ */
+	0x049d, 499,	/* ҝ Ҝ */
+	0x049f, 499,	/* ҟ Ҟ */
+	0x04a1, 499,	/* ҡ Ҡ */
+	0x04a3, 499,	/* ң Ң */
+	0x04a5, 499,	/* ҥ Ҥ */
+	0x04a7, 499,	/* ҧ Ҧ */
+	0x04a9, 499,	/* ҩ Ҩ */
+	0x04ab, 499,	/* ҫ Ҫ */
+	0x04ad, 499,	/* ҭ Ҭ */
+	0x04af, 499,	/* ү Ү */
+	0x04b1, 499,	/* ұ Ұ */
+	0x04b3, 499,	/* ҳ Ҳ */
+	0x04b5, 499,	/* ҵ Ҵ */
+	0x04b7, 499,	/* ҷ Ҷ */
+	0x04b9, 499,	/* ҹ Ҹ */
+	0x04bb, 499,	/* һ Һ */
+	0x04bd, 499,	/* ҽ Ҽ */
+	0x04bf, 499,	/* ҿ Ҿ */
+	0x04c2, 499,	/* ӂ Ӂ */
+	0x04c4, 499,	/* ӄ Ӄ */
+	0x04c8, 499,	/* ӈ Ӈ */
+	0x04cc, 499,	/* ӌ Ӌ */
+	0x04d1, 499,	/* ӑ Ӑ */
+	0x04d3, 499,	/* ӓ Ӓ */
+	0x04d5, 499,	/* ӕ Ӕ */
+	0x04d7, 499,	/* ӗ Ӗ */
+	0x04d9, 499,	/* ә Ә */
+	0x04db, 499,	/* ӛ Ӛ */
+	0x04dd, 499,	/* ӝ Ӝ */
+	0x04df, 499,	/* ӟ Ӟ */
+	0x04e1, 499,	/* ӡ Ӡ */
+	0x04e3, 499,	/* ӣ Ӣ */
+	0x04e5, 499,	/* ӥ Ӥ */
+	0x04e7, 499,	/* ӧ Ӧ */
+	0x04e9, 499,	/* ө Ө */
+	0x04eb, 499,	/* ӫ Ӫ */
+	0x04ef, 499,	/* ӯ Ӯ */
+	0x04f1, 499,	/* ӱ Ӱ */
+	0x04f3, 499,	/* ӳ Ӳ */
+	0x04f5, 499,	/* ӵ Ӵ */
+	0x04f9, 499,	/* ӹ Ӹ */
+	0x1e01, 499,	/* ḁ Ḁ */
+	0x1e03, 499,	/* ḃ Ḃ */
+	0x1e05, 499,	/* ḅ Ḅ */
+	0x1e07, 499,	/* ḇ Ḇ */
+	0x1e09, 499,	/* ḉ Ḉ */
+	0x1e0b, 499,	/* ḋ Ḋ */
+	0x1e0d, 499,	/* ḍ Ḍ */
+	0x1e0f, 499,	/* ḏ Ḏ */
+	0x1e11, 499,	/* ḑ Ḑ */
+	0x1e13, 499,	/* ḓ Ḓ */
+	0x1e15, 499,	/* ḕ Ḕ */
+	0x1e17, 499,	/* ḗ Ḗ */
+	0x1e19, 499,	/* ḙ Ḙ */
+	0x1e1b, 499,	/* ḛ Ḛ */
+	0x1e1d, 499,	/* ḝ Ḝ */
+	0x1e1f, 499,	/* ḟ Ḟ */
+	0x1e21, 499,	/* ḡ Ḡ */
+	0x1e23, 499,	/* ḣ Ḣ */
+	0x1e25, 499,	/* ḥ Ḥ */
+	0x1e27, 499,	/* ḧ Ḧ */
+	0x1e29, 499,	/* ḩ Ḩ */
+	0x1e2b, 499,	/* ḫ Ḫ */
+	0x1e2d, 499,	/* ḭ Ḭ */
+	0x1e2f, 499,	/* ḯ Ḯ */
+	0x1e31, 499,	/* ḱ Ḱ */
+	0x1e33, 499,	/* ḳ Ḳ */
+	0x1e35, 499,	/* ḵ Ḵ */
+	0x1e37, 499,	/* ḷ Ḷ */
+	0x1e39, 499,	/* ḹ Ḹ */
+	0x1e3b, 499,	/* ḻ Ḻ */
+	0x1e3d, 499,	/* ḽ Ḽ */
+	0x1e3f, 499,	/* ḿ Ḿ */
+	0x1e41, 499,	/* ṁ Ṁ */
+	0x1e43, 499,	/* ṃ Ṃ */
+	0x1e45, 499,	/* ṅ Ṅ */
+	0x1e47, 499,	/* ṇ Ṇ */
+	0x1e49, 499,	/* ṉ Ṉ */
+	0x1e4b, 499,	/* ṋ Ṋ */
+	0x1e4d, 499,	/* ṍ Ṍ */
+	0x1e4f, 499,	/* ṏ Ṏ */
+	0x1e51, 499,	/* ṑ Ṑ */
+	0x1e53, 499,	/* ṓ Ṓ */
+	0x1e55, 499,	/* ṕ Ṕ */
+	0x1e57, 499,	/* ṗ Ṗ */
+	0x1e59, 499,	/* ṙ Ṙ */
+	0x1e5b, 499,	/* ṛ Ṛ */
+	0x1e5d, 499,	/* ṝ Ṝ */
+	0x1e5f, 499,	/* ṟ Ṟ */
+	0x1e61, 499,	/* ṡ Ṡ */
+	0x1e63, 499,	/* ṣ Ṣ */
+	0x1e65, 499,	/* ṥ Ṥ */
+	0x1e67, 499,	/* ṧ Ṧ */
+	0x1e69, 499,	/* ṩ Ṩ */
+	0x1e6b, 499,	/* ṫ Ṫ */
+	0x1e6d, 499,	/* ṭ Ṭ */
+	0x1e6f, 499,	/* ṯ Ṯ */
+	0x1e71, 499,	/* ṱ Ṱ */
+	0x1e73, 499,	/* ṳ Ṳ */
+	0x1e75, 499,	/* ṵ Ṵ */
+	0x1e77, 499,	/* ṷ Ṷ */
+	0x1e79, 499,	/* ṹ Ṹ */
+	0x1e7b, 499,	/* ṻ Ṻ */
+	0x1e7d, 499,	/* ṽ Ṽ */
+	0x1e7f, 499,	/* ṿ Ṿ */
+	0x1e81, 499,	/* ẁ Ẁ */
+	0x1e83, 499,	/* ẃ Ẃ */
+	0x1e85, 499,	/* ẅ Ẅ */
+	0x1e87, 499,	/* ẇ Ẇ */
+	0x1e89, 499,	/* ẉ Ẉ */
+	0x1e8b, 499,	/* ẋ Ẋ */
+	0x1e8d, 499,	/* ẍ Ẍ */
+	0x1e8f, 499,	/* ẏ Ẏ */
+	0x1e91, 499,	/* ẑ Ẑ */
+	0x1e93, 499,	/* ẓ Ẓ */
+	0x1e95, 499,	/* ẕ Ẕ */
+	0x1ea1, 499,	/* ạ Ạ */
+	0x1ea3, 499,	/* ả Ả */
+	0x1ea5, 499,	/* ấ Ấ */
+	0x1ea7, 499,	/* ầ Ầ */
+	0x1ea9, 499,	/* ẩ Ẩ */
+	0x1eab, 499,	/* ẫ Ẫ */
+	0x1ead, 499,	/* ậ Ậ */
+	0x1eaf, 499,	/* ắ Ắ */
+	0x1eb1, 499,	/* ằ Ằ */
+	0x1eb3, 499,	/* ẳ Ẳ */
+	0x1eb5, 499,	/* ẵ Ẵ */
+	0x1eb7, 499,	/* ặ Ặ */
+	0x1eb9, 499,	/* ẹ Ẹ */
+	0x1ebb, 499,	/* ẻ Ẻ */
+	0x1ebd, 499,	/* ẽ Ẽ */
+	0x1ebf, 499,	/* ế Ế */
+	0x1ec1, 499,	/* ề Ề */
+	0x1ec3, 499,	/* ể Ể */
+	0x1ec5, 499,	/* ễ Ễ */
+	0x1ec7, 499,	/* ệ Ệ */
+	0x1ec9, 499,	/* ỉ Ỉ */
+	0x1ecb, 499,	/* ị Ị */
+	0x1ecd, 499,	/* ọ Ọ */
+	0x1ecf, 499,	/* ỏ Ỏ */
+	0x1ed1, 499,	/* ố Ố */
+	0x1ed3, 499,	/* ồ Ồ */
+	0x1ed5, 499,	/* ổ Ổ */
+	0x1ed7, 499,	/* ỗ Ỗ */
+	0x1ed9, 499,	/* ộ Ộ */
+	0x1edb, 499,	/* ớ Ớ */
+	0x1edd, 499,	/* ờ Ờ */
+	0x1edf, 499,	/* ở Ở */
+	0x1ee1, 499,	/* ỡ Ỡ */
+	0x1ee3, 499,	/* ợ Ợ */
+	0x1ee5, 499,	/* ụ Ụ */
+	0x1ee7, 499,	/* ủ Ủ */
+	0x1ee9, 499,	/* ứ Ứ */
+	0x1eeb, 499,	/* ừ Ừ */
+	0x1eed, 499,	/* ử Ử */
+	0x1eef, 499,	/* ữ Ữ */
+	0x1ef1, 499,	/* ự Ự */
+	0x1ef3, 499,	/* ỳ Ỳ */
+	0x1ef5, 499,	/* ỵ Ỵ */
+	0x1ef7, 499,	/* ỷ Ỷ */
+	0x1ef9, 499,	/* ỹ Ỹ */
+	0x1f51, 508,	/* ὑ Ὑ */
+	0x1f53, 508,	/* ὓ Ὓ */
+	0x1f55, 508,	/* ὕ Ὕ */
+	0x1f57, 508,	/* ὗ Ὗ */
+	0x1fb3, 509,	/* ᾳ ᾼ */
+	0x1fc3, 509,	/* ῃ ῌ */
+	0x1fe5, 507,	/* ῥ Ῥ */
+	0x1ff3, 509,	/* ῳ ῼ */
+};
+
+/*
+ * upper case ranges
+ *	3rd col is conversion excess 500
+ */
+static
+Rune	__tolower2[] =
+{
+	0x0041,	0x005a, 532,	/* A-Z a-z */
+	0x00c0,	0x00d6, 532,	/* À-Ö à-ö */
+	0x00d8,	0x00de, 532,	/* Ø-Þ ø-þ */
+	0x0189,	0x018a, 705,	/* Ɖ-Ɗ ɖ-ɗ */
+	0x018e,	0x018f, 702,	/* Ǝ-Ə ɘ-ə */
+	0x01b1,	0x01b2, 717,	/* Ʊ-Ʋ ʊ-ʋ */
+	0x0388,	0x038a, 537,	/* Έ-Ί έ-ί */
+	0x038e,	0x038f, 563,	/* Ύ-Ώ ύ-ώ */
+	0x0391,	0x03a1, 532,	/* Α-Ρ α-ρ */
+	0x03a3,	0x03ab, 532,	/* Σ-Ϋ σ-ϋ */
+	0x0401,	0x040c, 580,	/* Ё-Ќ ё-ќ */
+	0x040e,	0x040f, 580,	/* Ў-Џ ў-џ */
+	0x0410,	0x042f, 532,	/* А-Я а-я */
+	0x0531,	0x0556, 548,	/* Ա-Ֆ ա-ֆ */
+	0x10a0,	0x10c5, 548,	/* Ⴀ-Ⴥ ა-ჵ */
+	0x1f08,	0x1f0f, 492,	/* Ἀ-Ἇ ἀ-ἇ */
+	0x1f18,	0x1f1d, 492,	/* Ἐ-Ἕ ἐ-ἕ */
+	0x1f28,	0x1f2f, 492,	/* Ἠ-Ἧ ἠ-ἧ */
+	0x1f38,	0x1f3f, 492,	/* Ἰ-Ἷ ἰ-ἷ */
+	0x1f48,	0x1f4d, 492,	/* Ὀ-Ὅ ὀ-ὅ */
+	0x1f68,	0x1f6f, 492,	/* Ὠ-Ὧ ὠ-ὧ */
+	0x1f88,	0x1f8f, 492,	/* ᾈ-ᾏ ᾀ-ᾇ */
+	0x1f98,	0x1f9f, 492,	/* ᾘ-ᾟ ᾐ-ᾗ */
+	0x1fa8,	0x1faf, 492,	/* ᾨ-ᾯ ᾠ-ᾧ */
+	0x1fb8,	0x1fb9, 492,	/* Ᾰ-Ᾱ ᾰ-ᾱ */
+	0x1fba,	0x1fbb, 426,	/* Ὰ-Ά ὰ-ά */
+	0x1fc8,	0x1fcb, 414,	/* Ὲ-Ή ὲ-ή */
+	0x1fd8,	0x1fd9, 492,	/* Ῐ-Ῑ ῐ-ῑ */
+	0x1fda,	0x1fdb, 400,	/* Ὶ-Ί ὶ-ί */
+	0x1fe8,	0x1fe9, 492,	/* Ῠ-Ῡ ῠ-ῡ */
+	0x1fea,	0x1feb, 388,	/* Ὺ-Ύ ὺ-ύ */
+	0x1ff8,	0x1ff9, 372,	/* Ὸ-Ό ὸ-ό */
+	0x1ffa,	0x1ffb, 374,	/* Ὼ-Ώ ὼ-ώ */
+	0x2160,	0x216f, 516,	/* Ⅰ-Ⅿ ⅰ-ⅿ */
+	0x24b6,	0x24cf, 526,	/* Ⓐ-Ⓩ ⓐ-ⓩ */
+	0xff21,	0xff3a, 532,	/* Ａ-Ｚ ａ-ｚ */
+};
+
+/*
+ * upper case singlets
+ *	2nd col is conversion excess 500
+ */
+static
+Rune	__tolower1[] =
+{
+	0x0100, 501,	/* Ā ā */
+	0x0102, 501,	/* Ă ă */
+	0x0104, 501,	/* Ą ą */
+	0x0106, 501,	/* Ć ć */
+	0x0108, 501,	/* Ĉ ĉ */
+	0x010a, 501,	/* Ċ ċ */
+	0x010c, 501,	/* Č č */
+	0x010e, 501,	/* Ď ď */
+	0x0110, 501,	/* Đ đ */
+	0x0112, 501,	/* Ē ē */
+	0x0114, 501,	/* Ĕ ĕ */
+	0x0116, 501,	/* Ė ė */
+	0x0118, 501,	/* Ę ę */
+	0x011a, 501,	/* Ě ě */
+	0x011c, 501,	/* Ĝ ĝ */
+	0x011e, 501,	/* Ğ ğ */
+	0x0120, 501,	/* Ġ ġ */
+	0x0122, 501,	/* Ģ ģ */
+	0x0124, 501,	/* Ĥ ĥ */
+	0x0126, 501,	/* Ħ ħ */
+	0x0128, 501,	/* Ĩ ĩ */
+	0x012a, 501,	/* Ī ī */
+	0x012c, 501,	/* Ĭ ĭ */
+	0x012e, 501,	/* Į į */
+	0x0130, 301,	/* İ i */
+	0x0132, 501,	/* IJ ij */
+	0x0134, 501,	/* Ĵ ĵ */
+	0x0136, 501,	/* Ķ ķ */
+	0x0139, 501,	/* Ĺ ĺ */
+	0x013b, 501,	/* Ļ ļ */
+	0x013d, 501,	/* Ľ ľ */
+	0x013f, 501,	/* Ŀ ŀ */
+	0x0141, 501,	/* Ł ł */
+	0x0143, 501,	/* Ń ń */
+	0x0145, 501,	/* Ņ ņ */
+	0x0147, 501,	/* Ň ň */
+	0x014a, 501,	/* Ŋ ŋ */
+	0x014c, 501,	/* Ō ō */
+	0x014e, 501,	/* Ŏ ŏ */
+	0x0150, 501,	/* Ő ő */
+	0x0152, 501,	/* Œ œ */
+	0x0154, 501,	/* Ŕ ŕ */
+	0x0156, 501,	/* Ŗ ŗ */
+	0x0158, 501,	/* Ř ř */
+	0x015a, 501,	/* Ś ś */
+	0x015c, 501,	/* Ŝ ŝ */
+	0x015e, 501,	/* Ş ş */
+	0x0160, 501,	/* Š š */
+	0x0162, 501,	/* Ţ ţ */
+	0x0164, 501,	/* Ť ť */
+	0x0166, 501,	/* Ŧ ŧ */
+	0x0168, 501,	/* Ũ ũ */
+	0x016a, 501,	/* Ū ū */
+	0x016c, 501,	/* Ŭ ŭ */
+	0x016e, 501,	/* Ů ů */
+	0x0170, 501,	/* Ű ű */
+	0x0172, 501,	/* Ų ų */
+	0x0174, 501,	/* Ŵ ŵ */
+	0x0176, 501,	/* Ŷ ŷ */
+	0x0178, 379,	/* Ÿ ÿ */
+	0x0179, 501,	/* Ź ź */
+	0x017b, 501,	/* Ż ż */
+	0x017d, 501,	/* Ž ž */
+	0x0181, 710,	/* Ɓ ɓ */
+	0x0182, 501,	/* Ƃ ƃ */
+	0x0184, 501,	/* Ƅ ƅ */
+	0x0186, 706,	/* Ɔ ɔ */
+	0x0187, 501,	/* Ƈ ƈ */
+	0x018b, 501,	/* Ƌ ƌ */
+	0x0190, 703,	/* Ɛ ɛ */
+	0x0191, 501,	/* Ƒ ƒ */
+	0x0193, 705,	/* Ɠ ɠ */
+	0x0194, 707,	/* Ɣ ɣ */
+	0x0196, 711,	/* Ɩ ɩ */
+	0x0197, 709,	/* Ɨ ɨ */
+	0x0198, 501,	/* Ƙ ƙ */
+	0x019c, 711,	/* Ɯ ɯ */
+	0x019d, 713,	/* Ɲ ɲ */
+	0x01a0, 501,	/* Ơ ơ */
+	0x01a2, 501,	/* Ƣ ƣ */
+	0x01a4, 501,	/* Ƥ ƥ */
+	0x01a7, 501,	/* Ƨ ƨ */
+	0x01a9, 718,	/* Ʃ ʃ */
+	0x01ac, 501,	/* Ƭ ƭ */
+	0x01ae, 718,	/* Ʈ ʈ */
+	0x01af, 501,	/* Ư ư */
+	0x01b3, 501,	/* Ƴ ƴ */
+	0x01b5, 501,	/* Ƶ ƶ */
+	0x01b7, 719,	/* Ʒ ʒ */
+	0x01b8, 501,	/* Ƹ ƹ */
+	0x01bc, 501,	/* Ƽ ƽ */
+	0x01c4, 502,	/* DŽ dž */
+	0x01c5, 501,	/* Dž dž */
+	0x01c7, 502,	/* LJ lj */
+	0x01c8, 501,	/* Lj lj */
+	0x01ca, 502,	/* NJ nj */
+	0x01cb, 501,	/* Nj nj */
+	0x01cd, 501,	/* Ǎ ǎ */
+	0x01cf, 501,	/* Ǐ ǐ */
+	0x01d1, 501,	/* Ǒ ǒ */
+	0x01d3, 501,	/* Ǔ ǔ */
+	0x01d5, 501,	/* Ǖ ǖ */
+	0x01d7, 501,	/* Ǘ ǘ */
+	0x01d9, 501,	/* Ǚ ǚ */
+	0x01db, 501,	/* Ǜ ǜ */
+	0x01de, 501,	/* Ǟ ǟ */
+	0x01e0, 501,	/* Ǡ ǡ */
+	0x01e2, 501,	/* Ǣ ǣ */
+	0x01e4, 501,	/* Ǥ ǥ */
+	0x01e6, 501,	/* Ǧ ǧ */
+	0x01e8, 501,	/* Ǩ ǩ */
+	0x01ea, 501,	/* Ǫ ǫ */
+	0x01ec, 501,	/* Ǭ ǭ */
+	0x01ee, 501,	/* Ǯ ǯ */
+	0x01f1, 502,	/* DZ dz */
+	0x01f2, 501,	/* Dz dz */
+	0x01f4, 501,	/* Ǵ ǵ */
+	0x01fa, 501,	/* Ǻ ǻ */
+	0x01fc, 501,	/* Ǽ ǽ */
+	0x01fe, 501,	/* Ǿ ǿ */
+	0x0200, 501,	/* Ȁ ȁ */
+	0x0202, 501,	/* Ȃ ȃ */
+	0x0204, 501,	/* Ȅ ȅ */
+	0x0206, 501,	/* Ȇ ȇ */
+	0x0208, 501,	/* Ȉ ȉ */
+	0x020a, 501,	/* Ȋ ȋ */
+	0x020c, 501,	/* Ȍ ȍ */
+	0x020e, 501,	/* Ȏ ȏ */
+	0x0210, 501,	/* Ȑ ȑ */
+	0x0212, 501,	/* Ȓ ȓ */
+	0x0214, 501,	/* Ȕ ȕ */
+	0x0216, 501,	/* Ȗ ȗ */
+	0x0386, 538,	/* Ά ά */
+	0x038c, 564,	/* Ό ό */
+	0x03e2, 501,	/* Ϣ ϣ */
+	0x03e4, 501,	/* Ϥ ϥ */
+	0x03e6, 501,	/* Ϧ ϧ */
+	0x03e8, 501,	/* Ϩ ϩ */
+	0x03ea, 501,	/* Ϫ ϫ */
+	0x03ec, 501,	/* Ϭ ϭ */
+	0x03ee, 501,	/* Ϯ ϯ */
+	0x0460, 501,	/* Ѡ ѡ */
+	0x0462, 501,	/* Ѣ ѣ */
+	0x0464, 501,	/* Ѥ ѥ */
+	0x0466, 501,	/* Ѧ ѧ */
+	0x0468, 501,	/* Ѩ ѩ */
+	0x046a, 501,	/* Ѫ ѫ */
+	0x046c, 501,	/* Ѭ ѭ */
+	0x046e, 501,	/* Ѯ ѯ */
+	0x0470, 501,	/* Ѱ ѱ */
+	0x0472, 501,	/* Ѳ ѳ */
+	0x0474, 501,	/* Ѵ ѵ */
+	0x0476, 501,	/* Ѷ ѷ */
+	0x0478, 501,	/* Ѹ ѹ */
+	0x047a, 501,	/* Ѻ ѻ */
+	0x047c, 501,	/* Ѽ ѽ */
+	0x047e, 501,	/* Ѿ ѿ */
+	0x0480, 501,	/* Ҁ ҁ */
+	0x0490, 501,	/* Ґ ґ */
+	0x0492, 501,	/* Ғ ғ */
+	0x0494, 501,	/* Ҕ ҕ */
+	0x0496, 501,	/* Җ җ */
+	0x0498, 501,	/* Ҙ ҙ */
+	0x049a, 501,	/* Қ қ */
+	0x049c, 501,	/* Ҝ ҝ */
+	0x049e, 501,	/* Ҟ ҟ */
+	0x04a0, 501,	/* Ҡ ҡ */
+	0x04a2, 501,	/* Ң ң */
+	0x04a4, 501,	/* Ҥ ҥ */
+	0x04a6, 501,	/* Ҧ ҧ */
+	0x04a8, 501,	/* Ҩ ҩ */
+	0x04aa, 501,	/* Ҫ ҫ */
+	0x04ac, 501,	/* Ҭ ҭ */
+	0x04ae, 501,	/* Ү ү */
+	0x04b0, 501,	/* Ұ ұ */
+	0x04b2, 501,	/* Ҳ ҳ */
+	0x04b4, 501,	/* Ҵ ҵ */
+	0x04b6, 501,	/* Ҷ ҷ */
+	0x04b8, 501,	/* Ҹ ҹ */
+	0x04ba, 501,	/* Һ һ */
+	0x04bc, 501,	/* Ҽ ҽ */
+	0x04be, 501,	/* Ҿ ҿ */
+	0x04c1, 501,	/* Ӂ ӂ */
+	0x04c3, 501,	/* Ӄ ӄ */
+	0x04c7, 501,	/* Ӈ ӈ */
+	0x04cb, 501,	/* Ӌ ӌ */
+	0x04d0, 501,	/* Ӑ ӑ */
+	0x04d2, 501,	/* Ӓ ӓ */
+	0x04d4, 501,	/* Ӕ ӕ */
+	0x04d6, 501,	/* Ӗ ӗ */
+	0x04d8, 501,	/* Ә ә */
+	0x04da, 501,	/* Ӛ ӛ */
+	0x04dc, 501,	/* Ӝ ӝ */
+	0x04de, 501,	/* Ӟ ӟ */
+	0x04e0, 501,	/* Ӡ ӡ */
+	0x04e2, 501,	/* Ӣ ӣ */
+	0x04e4, 501,	/* Ӥ ӥ */
+	0x04e6, 501,	/* Ӧ ӧ */
+	0x04e8, 501,	/* Ө ө */
+	0x04ea, 501,	/* Ӫ ӫ */
+	0x04ee, 501,	/* Ӯ ӯ */
+	0x04f0, 501,	/* Ӱ ӱ */
+	0x04f2, 501,	/* Ӳ ӳ */
+	0x04f4, 501,	/* Ӵ ӵ */
+	0x04f8, 501,	/* Ӹ ӹ */
+	0x1e00, 501,	/* Ḁ ḁ */
+	0x1e02, 501,	/* Ḃ ḃ */
+	0x1e04, 501,	/* Ḅ ḅ */
+	0x1e06, 501,	/* Ḇ ḇ */
+	0x1e08, 501,	/* Ḉ ḉ */
+	0x1e0a, 501,	/* Ḋ ḋ */
+	0x1e0c, 501,	/* Ḍ ḍ */
+	0x1e0e, 501,	/* Ḏ ḏ */
+	0x1e10, 501,	/* Ḑ ḑ */
+	0x1e12, 501,	/* Ḓ ḓ */
+	0x1e14, 501,	/* Ḕ ḕ */
+	0x1e16, 501,	/* Ḗ ḗ */
+	0x1e18, 501,	/* Ḙ ḙ */
+	0x1e1a, 501,	/* Ḛ ḛ */
+	0x1e1c, 501,	/* Ḝ ḝ */
+	0x1e1e, 501,	/* Ḟ ḟ */
+	0x1e20, 501,	/* Ḡ ḡ */
+	0x1e22, 501,	/* Ḣ ḣ */
+	0x1e24, 501,	/* Ḥ ḥ */
+	0x1e26, 501,	/* Ḧ ḧ */
+	0x1e28, 501,	/* Ḩ ḩ */
+	0x1e2a, 501,	/* Ḫ ḫ */
+	0x1e2c, 501,	/* Ḭ ḭ */
+	0x1e2e, 501,	/* Ḯ ḯ */
+	0x1e30, 501,	/* Ḱ ḱ */
+	0x1e32, 501,	/* Ḳ ḳ */
+	0x1e34, 501,	/* Ḵ ḵ */
+	0x1e36, 501,	/* Ḷ ḷ */
+	0x1e38, 501,	/* Ḹ ḹ */
+	0x1e3a, 501,	/* Ḻ ḻ */
+	0x1e3c, 501,	/* Ḽ ḽ */
+	0x1e3e, 501,	/* Ḿ ḿ */
+	0x1e40, 501,	/* Ṁ ṁ */
+	0x1e42, 501,	/* Ṃ ṃ */
+	0x1e44, 501,	/* Ṅ ṅ */
+	0x1e46, 501,	/* Ṇ ṇ */
+	0x1e48, 501,	/* Ṉ ṉ */
+	0x1e4a, 501,	/* Ṋ ṋ */
+	0x1e4c, 501,	/* Ṍ ṍ */
+	0x1e4e, 501,	/* Ṏ ṏ */
+	0x1e50, 501,	/* Ṑ ṑ */
+	0x1e52, 501,	/* Ṓ ṓ */
+	0x1e54, 501,	/* Ṕ ṕ */
+	0x1e56, 501,	/* Ṗ ṗ */
+	0x1e58, 501,	/* Ṙ ṙ */
+	0x1e5a, 501,	/* Ṛ ṛ */
+	0x1e5c, 501,	/* Ṝ ṝ */
+	0x1e5e, 501,	/* Ṟ ṟ */
+	0x1e60, 501,	/* Ṡ ṡ */
+	0x1e62, 501,	/* Ṣ ṣ */
+	0x1e64, 501,	/* Ṥ ṥ */
+	0x1e66, 501,	/* Ṧ ṧ */
+	0x1e68, 501,	/* Ṩ ṩ */
+	0x1e6a, 501,	/* Ṫ ṫ */
+	0x1e6c, 501,	/* Ṭ ṭ */
+	0x1e6e, 501,	/* Ṯ ṯ */
+	0x1e70, 501,	/* Ṱ ṱ */
+	0x1e72, 501,	/* Ṳ ṳ */
+	0x1e74, 501,	/* Ṵ ṵ */
+	0x1e76, 501,	/* Ṷ ṷ */
+	0x1e78, 501,	/* Ṹ ṹ */
+	0x1e7a, 501,	/* Ṻ ṻ */
+	0x1e7c, 501,	/* Ṽ ṽ */
+	0x1e7e, 501,	/* Ṿ ṿ */
+	0x1e80, 501,	/* Ẁ ẁ */
+	0x1e82, 501,	/* Ẃ ẃ */
+	0x1e84, 501,	/* Ẅ ẅ */
+	0x1e86, 501,	/* Ẇ ẇ */
+	0x1e88, 501,	/* Ẉ ẉ */
+	0x1e8a, 501,	/* Ẋ ẋ */
+	0x1e8c, 501,	/* Ẍ ẍ */
+	0x1e8e, 501,	/* Ẏ ẏ */
+	0x1e90, 501,	/* Ẑ ẑ */
+	0x1e92, 501,	/* Ẓ ẓ */
+	0x1e94, 501,	/* Ẕ ẕ */
+	0x1ea0, 501,	/* Ạ ạ */
+	0x1ea2, 501,	/* Ả ả */
+	0x1ea4, 501,	/* Ấ ấ */
+	0x1ea6, 501,	/* Ầ ầ */
+	0x1ea8, 501,	/* Ẩ ẩ */
+	0x1eaa, 501,	/* Ẫ ẫ */
+	0x1eac, 501,	/* Ậ ậ */
+	0x1eae, 501,	/* Ắ ắ */
+	0x1eb0, 501,	/* Ằ ằ */
+	0x1eb2, 501,	/* Ẳ ẳ */
+	0x1eb4, 501,	/* Ẵ ẵ */
+	0x1eb6, 501,	/* Ặ ặ */
+	0x1eb8, 501,	/* Ẹ ẹ */
+	0x1eba, 501,	/* Ẻ ẻ */
+	0x1ebc, 501,	/* Ẽ ẽ */
+	0x1ebe, 501,	/* Ế ế */
+	0x1ec0, 501,	/* Ề ề */
+	0x1ec2, 501,	/* Ể ể */
+	0x1ec4, 501,	/* Ễ ễ */
+	0x1ec6, 501,	/* Ệ ệ */
+	0x1ec8, 501,	/* Ỉ ỉ */
+	0x1eca, 501,	/* Ị ị */
+	0x1ecc, 501,	/* Ọ ọ */
+	0x1ece, 501,	/* Ỏ ỏ */
+	0x1ed0, 501,	/* Ố ố */
+	0x1ed2, 501,	/* Ồ ồ */
+	0x1ed4, 501,	/* Ổ ổ */
+	0x1ed6, 501,	/* Ỗ ỗ */
+	0x1ed8, 501,	/* Ộ ộ */
+	0x1eda, 501,	/* Ớ ớ */
+	0x1edc, 501,	/* Ờ ờ */
+	0x1ede, 501,	/* Ở ở */
+	0x1ee0, 501,	/* Ỡ ỡ */
+	0x1ee2, 501,	/* Ợ ợ */
+	0x1ee4, 501,	/* Ụ ụ */
+	0x1ee6, 501,	/* Ủ ủ */
+	0x1ee8, 501,	/* Ứ ứ */
+	0x1eea, 501,	/* Ừ ừ */
+	0x1eec, 501,	/* Ử ử */
+	0x1eee, 501,	/* Ữ ữ */
+	0x1ef0, 501,	/* Ự ự */
+	0x1ef2, 501,	/* Ỳ ỳ */
+	0x1ef4, 501,	/* Ỵ ỵ */
+	0x1ef6, 501,	/* Ỷ ỷ */
+	0x1ef8, 501,	/* Ỹ ỹ */
+	0x1f59, 492,	/* Ὑ ὑ */
+	0x1f5b, 492,	/* Ὓ ὓ */
+	0x1f5d, 492,	/* Ὕ ὕ */
+	0x1f5f, 492,	/* Ὗ ὗ */
+	0x1fbc, 491,	/* ᾼ ᾳ */
+	0x1fcc, 491,	/* ῌ ῃ */
+	0x1fec, 493,	/* Ῥ ῥ */
+	0x1ffc, 491,	/* ῼ ῳ */
+};
+
+/*
+ * title characters are those between
+ * upper and lower case. ie DZ Dz dz
+ */
+static
+Rune	__totitle1[] =
+{
+	0x01c4, 501,	/* DŽ Dž */
+	0x01c6, 499,	/* dž Dž */
+	0x01c7, 501,	/* LJ Lj */
+	0x01c9, 499,	/* lj Lj */
+	0x01ca, 501,	/* NJ Nj */
+	0x01cc, 499,	/* nj Nj */
+	0x01f1, 501,	/* DZ Dz */
+	0x01f3, 499,	/* dz Dz */
+};
+
+static
+Rune*
+bsearch(Rune c, Rune *t, int n, int ne)
+{
+	Rune *p;
+	int m;
+
+	while(n > 1) {
+		m = n/2;
+		p = t + m*ne;
+		if(c >= p[0]) {
+			t = p;
+			n = n-m;
+		} else
+			n = m;
+	}
+	if(n && c >= t[0])
+		return t;
+	return 0;
+}
+
+Rune
+tolowerrune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __tolower2, nelem(__tolower2)/3, 3);
+	if(p && c >= p[0] && c <= p[1])
+		return c + p[2] - 500;
+	p = bsearch(c, __tolower1, nelem(__tolower1)/2, 2);
+	if(p && c == p[0])
+		return c + p[1] - 500;
+	return c;
+}
+
+Rune
+toupperrune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __toupper2, nelem(__toupper2)/3, 3);
+	if(p && c >= p[0] && c <= p[1])
+		return c + p[2] - 500;
+	p = bsearch(c, __toupper1, nelem(__toupper1)/2, 2);
+	if(p && c == p[0])
+		return c + p[1] - 500;
+	return c;
+}
+
+Rune
+totitlerune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __totitle1, nelem(__totitle1)/2, 2);
+	if(p && c == p[0])
+		return c + p[1] - 500;
+	return c;
+}
+
+int
+islowerrune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __toupper2, nelem(__toupper2)/3, 3);
+	if(p && c >= p[0] && c <= p[1])
+		return 1;
+	p = bsearch(c, __toupper1, nelem(__toupper1)/2, 2);
+	if(p && c == p[0])
+		return 1;
+	return 0;
+}
+
+int
+isupperrune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __tolower2, nelem(__tolower2)/3, 3);
+	if(p && c >= p[0] && c <= p[1])
+		return 1;
+	p = bsearch(c, __tolower1, nelem(__tolower1)/2, 2);
+	if(p && c == p[0])
+		return 1;
+	return 0;
+}
+
+int
+isalpharune(Rune c)
+{
+	Rune *p;
+
+	if(isupperrune(c) || islowerrune(c))
+		return 1;
+	p = bsearch(c, __alpha2, nelem(__alpha2)/2, 2);
+	if(p && c >= p[0] && c <= p[1])
+		return 1;
+	p = bsearch(c, __alpha1, nelem(__alpha1), 1);
+	if(p && c == p[0])
+		return 1;
+	return 0;
+}
+
+int
+istitlerune(Rune c)
+{
+	return isupperrune(c) && islowerrune(c);
+}
+
+int
+isspacerune(Rune c)
+{
+	Rune *p;
+
+	p = bsearch(c, __space2, nelem(__space2)/2, 2);
+	if(p && c >= p[0] && c <= p[1])
+		return 1;
+	return 0;
+}
diff --git a/sys/src/ape/lib/utf/utfdef.h b/sys/src/ape/lib/utf/utfdef.h
new file mode 100755
index 000000000..4b58ae87e
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfdef.h
@@ -0,0 +1,14 @@
+#define uchar _utfuchar
+#define ushort _utfushort
+#define uint _utfuint
+#define ulong _utfulong
+#define vlong _utfvlong
+#define uvlong _utfuvlong
+
+typedef unsigned char		uchar;
+typedef unsigned short		ushort;
+typedef unsigned int		uint;
+typedef unsigned long		ulong;
+
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+#define nil ((void*)0)
diff --git a/sys/src/ape/lib/utf/utfecpy.c b/sys/src/ape/lib/utf/utfecpy.c
new file mode 100755
index 000000000..571593503
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfecpy.c
@@ -0,0 +1,36 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+char*
+utfecpy(char *to, char *e, char *from)
+{
+	char *end;
+
+	if(to >= e)
+		return to;
+	end = memccpy(to, from, '\0', e - to);
+	if(end == nil){
+		end = e-1;
+		while(end>to && (*--end&0xC0)==0x80)
+			;
+		*end = '\0';
+	}else{
+		end--;
+	}
+	return end;
+}
diff --git a/sys/src/ape/lib/utf/utflen.c b/sys/src/ape/lib/utf/utflen.c
new file mode 100755
index 000000000..9d24ccf23
--- /dev/null
+++ b/sys/src/ape/lib/utf/utflen.c
@@ -0,0 +1,37 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+int
+utflen(char *s)
+{
+	int c;
+	long n;
+	Rune rune;
+
+	n = 0;
+	for(;;) {
+		c = *(uchar*)s;
+		if(c < Runeself) {
+			if(c == 0)
+				return n;
+			s++;
+		} else
+			s += chartorune(&rune, s);
+		n++;
+	}
+}
diff --git a/sys/src/ape/lib/utf/utfnlen.c b/sys/src/ape/lib/utf/utfnlen.c
new file mode 100755
index 000000000..66d674fd2
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfnlen.c
@@ -0,0 +1,41 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+int
+utfnlen(char *s, long m)
+{
+	int c;
+	long n;
+	Rune rune;
+	char *es;
+
+	es = s + m;
+	for(n = 0; s < es; n++) {
+		c = *(uchar*)s;
+		if(c < Runeself){
+			if(c == '\0')
+				break;
+			s++;
+			continue;
+		}
+		if(!fullrune(s, es-s))
+			break;
+		s += chartorune(&rune, s);
+	}
+	return n;
+}
diff --git a/sys/src/ape/lib/utf/utfrrune.c b/sys/src/ape/lib/utf/utfrrune.c
new file mode 100755
index 000000000..1f951feeb
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfrrune.c
@@ -0,0 +1,45 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+char*
+utfrrune(char *s, long c)
+{
+	long c1;
+	Rune r;
+	char *s1;
+
+	if(c < Runesync)		/* not part of utf sequence */
+		return strrchr(s, c);
+
+	s1 = 0;
+	for(;;) {
+		c1 = *(uchar*)s;
+		if(c1 < Runeself) {	/* one byte rune */
+			if(c1 == 0)
+				return s1;
+			if(c1 == c)
+				s1 = s;
+			s++;
+			continue;
+		}
+		c1 = chartorune(&r, s);
+		if(r == c)
+			s1 = s;
+		s += c1;
+	}
+}
diff --git a/sys/src/ape/lib/utf/utfrune.c b/sys/src/ape/lib/utf/utfrune.c
new file mode 100755
index 000000000..a98004d2a
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfrune.c
@@ -0,0 +1,44 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+char*
+utfrune(char *s, long c)
+{
+	long c1;
+	Rune r;
+	int n;
+
+	if(c < Runesync)		/* not part of utf sequence */
+		return strchr(s, c);
+
+	for(;;) {
+		c1 = *(uchar*)s;
+		if(c1 < Runeself) {	/* one byte rune */
+			if(c1 == 0)
+				return 0;
+			if(c1 == c)
+				return s;
+			s++;
+			continue;
+		}
+		n = chartorune(&r, s);
+		if(r == c)
+			return s;
+		s += n;
+	}
+}
diff --git a/sys/src/ape/lib/utf/utfutf.c b/sys/src/ape/lib/utf/utfutf.c
new file mode 100755
index 000000000..ea3603612
--- /dev/null
+++ b/sys/src/ape/lib/utf/utfutf.c
@@ -0,0 +1,41 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+#include <stdarg.h>
+#include <string.h>
+#include "utf.h"
+#include "utfdef.h"
+
+
+/*
+ * Return pointer to first occurrence of s2 in s1,
+ * 0 if none
+ */
+char*
+utfutf(char *s1, char *s2)
+{
+	char *p;
+	long f, n1, n2;
+	Rune r;
+
+	n1 = chartorune(&r, s2);
+	f = r;
+	if(f <= Runesync)		/* represents self */
+		return strstr(s1, s2);
+
+	n2 = strlen(s2);
+	for(p=s1; p=utfrune(p, f); p+=n1)
+		if(strncmp(p, s2, n2) == 0)
+			return p;
+	return 0;
+}
diff --git a/sys/src/ape/lib/v/error.c b/sys/src/ape/lib/v/error.c
new file mode 100755
index 000000000..6dccc463e
--- /dev/null
+++ b/sys/src/ape/lib/v/error.c
@@ -0,0 +1,14 @@
+#define _POSIX_SOURCE
+#define _RESEARCH_SOURCE
+#include <error.h>
+#include <stdio.h>
+#include <libv.h>
+
+char *_progname;
+
+void
+_perror(char *s)
+{
+	fprintf(stderr, "%s: ", _progname);
+	perror(s);
+}
diff --git a/sys/src/ape/lib/v/getfields.c b/sys/src/ape/lib/v/getfields.c
new file mode 100755
index 000000000..da59216d9
--- /dev/null
+++ b/sys/src/ape/lib/v/getfields.c
@@ -0,0 +1,136 @@
+#define _RESEARCH_SOURCE
+#include <libv.h>
+#include <string.h>
+
+static char is_sep[256] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	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, 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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+static char is_field[256] = {
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+};
+static char last_sep[256];
+
+char *
+setfields(char *arg)
+{
+	register unsigned char *s;
+	register i;
+
+	for(i = 1, s = (unsigned char *)last_sep; i < 256; i++)
+		if(is_sep[i])
+			*s++ = i;
+	*s = 0;
+	memset(is_sep, 0, sizeof is_sep);
+	memset(is_field, 1, sizeof is_field);
+	for(s = (unsigned char *)arg; *s;){
+		is_sep[*s] = 1;
+		is_field[*s++] = 0;
+	}
+	is_field[0] = 0;
+	return(last_sep);
+}
+
+int
+getfields(char *ss, char **sp, int nptrs)
+{
+	register unsigned char *s = (unsigned char *)ss;
+	register unsigned char **p = (unsigned char **)sp;
+	register unsigned c;
+
+	for(;;){
+		if(--nptrs < 0) break;
+		*p++ = s;
+		while(is_field[c = *s++])
+			;
+		if(c == 0) break;
+		s[-1] = 0;
+	}
+	if(nptrs > 0)
+		*p = 0;
+	else if(--s >= (unsigned char *)ss)
+		*s = c;
+	return(p - (unsigned char **)sp);
+}
+
+int
+getmfields(char *ss, char **sp, int nptrs)
+{
+	register unsigned char *s = (unsigned char *)ss;
+	register unsigned char **p = (unsigned char **)sp;
+	register unsigned c;
+
+	if(nptrs <= 0)
+		return(0);
+	goto flushdelim;
+	for(;;){
+		*p++ = s;
+		if(--nptrs == 0) break;
+		while(is_field[c = *s++])
+			;
+		/*
+		 *  s is now pointing 1 past the delimiter of the last field
+		 *  c is the delimiter
+		 */
+		if(c == 0) break;
+		s[-1] = 0;
+	flushdelim:
+		while(is_sep[c = *s++])
+			;
+		/*
+		 *  s is now pointing 1 past the beginning of the next field
+		 *  c is the first letter of the field
+		 */
+		if(c == 0) break;
+		s--;
+		/*
+		 *  s is now pointing to the beginning of the next field
+		 *  c is the first letter of the field
+		 */
+	}
+	if(nptrs > 0)
+		*p = 0;
+	return(p - (unsigned char **)sp);
+}
+
+#ifdef	MAIN
+#include	<fio.h>
+
+main()
+{
+	char *fields[256];
+	char *s;
+	int n, i;
+	char buf[1024];
+
+	print("go:\n");
+	while(s = Frdline(0)){
+		strcpy(buf, s);
+		Fprint(1, "getf:");
+		n = getfields(s, fields, 4);
+		for(i = 0; i < n; i++)
+			Fprint(1, " >%s<", fields[i]);
+		Fputc(1, '\n');
+		Fprint(1, "getmf:");
+		n = getmfields(buf, fields, 4);
+		for(i = 0; i < n; i++)
+			Fprint(1, " >%s<", fields[i]);
+		Fputc(1, '\n');
+		Fflush(1);
+	}
+	exit(0);
+}
+#endif
diff --git a/sys/src/ape/lib/v/max.c b/sys/src/ape/lib/v/max.c
new file mode 100755
index 000000000..c8a105567
--- /dev/null
+++ b/sys/src/ape/lib/v/max.c
@@ -0,0 +1,7 @@
+#define _RESEARCH_SOURCE
+#include <libv.h>
+
+max(int a, int b)
+{
+	return (a>b? a: b);
+}
diff --git a/sys/src/ape/lib/v/min.c b/sys/src/ape/lib/v/min.c
new file mode 100755
index 000000000..f0502af0c
--- /dev/null
+++ b/sys/src/ape/lib/v/min.c
@@ -0,0 +1,7 @@
+#define _RESEARCH_SOURCE
+#include <libv.h>
+
+min(int a, int b)
+{
+	return (a<b? a: b);
+}
diff --git a/sys/src/ape/lib/v/mkfile b/sys/src/ape/lib/v/mkfile
new file mode 100755
index 000000000..fa3c8217f
--- /dev/null
+++ b/sys/src/ape/lib/v/mkfile
@@ -0,0 +1,21 @@
+APE=/sys/src/ape
+<$APE/config
+
+LIB=/$objtype/lib/ape/libv.a
+
+OFILES=getpass.$O\
+	tty.$O\
+	rand.$O\
+	nrand.$O\
+	getfields.$O\
+	min.$O\
+	max.$O\
+	error.$O\
+	nap.$O
+
+</sys/src/cmd/mksyslib
+
+CFLAGS=-c
+
+%.$O:	$FAMILY/%.c
+	$CC $CFLAGS $prereq
diff --git a/sys/src/ape/lib/v/nap.c b/sys/src/ape/lib/v/nap.c
new file mode 100755
index 000000000..490857d27
--- /dev/null
+++ b/sys/src/ape/lib/v/nap.c
@@ -0,0 +1,9 @@
+nap(int n)
+{
+	register i;
+
+	while(n-- > 0){
+		for(i = 0; i < 1000*1000*10; i++)
+			;
+	}
+}
diff --git a/sys/src/ape/lib/v/nrand.c b/sys/src/ape/lib/v/nrand.c
new file mode 100755
index 000000000..29e5aee0f
--- /dev/null
+++ b/sys/src/ape/lib/v/nrand.c
@@ -0,0 +1,24 @@
+#include <stdlib.h>
+
+#define	MASK	0x7FFFFFFFL
+#define	FRACT	(1.0 / (MASK + 1.0))
+
+extern long lrand(void);
+
+double
+frand(void)
+{
+
+	return lrand() * FRACT;
+}
+
+nrand(int n)
+{
+	long slop, v;
+
+	slop = MASK % n;
+	do
+		v = lrand();
+	while(v <= slop);
+	return v % n;
+}
diff --git a/sys/src/ape/lib/v/plan9/getpass.c b/sys/src/ape/lib/v/plan9/getpass.c
new file mode 100755
index 000000000..f8f6a8e89
--- /dev/null
+++ b/sys/src/ape/lib/v/plan9/getpass.c
@@ -0,0 +1,42 @@
+#define _POSIX_SOURCE
+#define _RESEARCH_SOURCE
+#include <stdio.h>
+#include <signal.h>
+#include <libv.h>
+
+char *
+getpass(char *prompt)
+{
+	int c;
+	char *p;
+	FILE *fi;
+	static char pbuf[9];
+	void (*sig)(int);
+
+	if ((fi = fopen("/dev/cons", "r")) == NULL)
+		fi = stdin;
+	else
+		setbuf(fi, NULL);
+	sig = signal(SIGINT, SIG_IGN);
+	tty_echooff(fileno(fi));
+	fprintf(stderr, "%s", prompt);
+	fflush(stderr);
+
+	for (p = pbuf; (c = getc(fi)) != '\n' && c != EOF; )
+		if (c == ('u' & 037))
+			p = pbuf;
+		else if (c == '\b') {
+			if (p > pbuf)
+				p--;
+		} else if (p < &pbuf[8])
+			*p++ = c;
+	*p = '\0';
+
+	fprintf(stderr, "\n");
+	fflush(stderr);
+	tty_echoon(fileno(fi));
+	signal(SIGINT, sig);
+	if (fi != stdin)
+		fclose(fi);
+	return(pbuf);
+}
diff --git a/sys/src/ape/lib/v/plan9/tty.c b/sys/src/ape/lib/v/plan9/tty.c
new file mode 100755
index 000000000..dae26d48f
--- /dev/null
+++ b/sys/src/ape/lib/v/plan9/tty.c
@@ -0,0 +1,37 @@
+/*
+ * turn raw (no echo, etc.) on and off.
+ * ptyfs is gone, so don't even try tcsetattr, etc.
+ */
+#define _POSIX_SOURCE
+#define _RESEARCH_SOURCE
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <libv.h>
+
+static int ctlfd = -1;
+
+/* fd is ignored */
+
+tty_echooff(int fd)
+{
+	if(ctlfd >= 0)
+		return 0;
+	ctlfd = open("/dev/consctl", O_WRONLY);
+	if(ctlfd < 0)
+		return -1;
+	write(ctlfd, "rawon", 5);
+	return 0;
+}
+
+tty_echoon(int fd)
+{
+	if(ctlfd >= 0){
+		write(ctlfd, "rawoff", 6);
+		close(ctlfd);
+		ctlfd = -1;
+		return 0;
+	}
+	return -1;
+}
diff --git a/sys/src/ape/lib/v/rand.c b/sys/src/ape/lib/v/rand.c
new file mode 100755
index 000000000..4996b0c26
--- /dev/null
+++ b/sys/src/ape/lib/v/rand.c
@@ -0,0 +1,64 @@
+#define _RESEARCH_SOURCE
+#include <stdlib.h>
+#include <libv.h>
+/*
+	random number generator from cacm 31 10, oct 88
+	for 32 bit integers (called long here)
+*/
+
+#ifdef	MAIN
+#define	A	16807
+#define	M	2147483647
+#define	Q	127773
+#define	R	2836
+#else
+#define	A	48271
+#define	M	2147483647
+#define	Q	44488
+#define	R	3399
+#endif
+
+static long seed = 1;
+
+void
+srand(unsigned int newseed)
+{
+	seed = newseed;
+}
+
+long
+lrand(void)
+{
+	long lo, hi, test;
+
+	hi = seed/Q;
+	lo = seed%Q;
+	test = A*lo - R*hi;
+	if(test > 0)
+		seed = test;
+	else
+		seed = test+M;
+	return(seed);
+}
+
+int
+rand(void)
+{
+	return lrand()%(RAND_MAX+1);
+}
+
+#ifdef	MAIN
+
+main()
+{
+	int i;
+
+	for(i = 0; i < 10000; i++)
+		rand();
+	if(seed == 1043618065)
+		printf("     rand: pass\n");
+	else
+		printf("*****rand: fail; seed=%u, should be 1043618065\n", seed);
+	exit(0);
+}
+#endif