#include <u.h>
#include <libc.h>
#include <draw.h>
/* track made in sam + a sort of scripting language + games/opl3:
tool: http://runjimmyrunrunyoufuckerrun.com/audio/oplscript/oplscript.c
script: http://runjimmyrunrunyoufuckerrun.com/audio/oplscript/pjw
but I figure it's kinder just to include the output (-d flag), even tho it's huge...
*/
uchar ♪[] = {
#include "pjw.opl"
};
enum{↑, →, ↓, ←, 𝅘𝅥𝅱 = 21551724LL, 𝅝 = 1379310344LL/* nanoseconds @ 174 bpm */};
vlong nextframe, nextfx;
uchar *blatbuf, pxbuf[2 * 256 * 256], *pixels = pxbuf, pjwpx[256 * 256];
Image *px, *kpx, *peter;
Point worig;
Rectangle r;
Font *vga№1;
int wctl, xmax, ymax, blowup, grey;
Image *scanline[2];
ushort facebits[] = {
#include "/lib/face/48x48x1/p/pjw.1"
#include "/lib/face/48x48x1/b/bwk.1"
#include "/lib/face/48x48x1/d/dmr.1"
#include "/lib/face/48x48x1/k/ken.1"
#include "/lib/face/48x48x1/h/howard.1"
#include "/lib/face/48x48x1/p/presotto.1"
#include "/lib/face/48x48x1/j/judy.1"
#include "/lib/face/48x48x1/p/philw.1"
#include "/lib/face/48x48x1/t/td.1"
#include "/lib/face/48x48x1/s/seanq.1"
#include "/lib/face/48x48x1/b/bobf.1"
#include "/lib/face/48x48x1/r/rob.2"
};
uchar d12face[48 * 48 * 12];
Image*
imgalloc(int x, int y, ulong chan, int repl, ulong fill){
	Image *i;
	i = allocimage(display, Rect(0, 0, x, y), chan, repl, fill);
	if(i == nil) sysfatal("allocimage: %r");
	return i;
}
void
centre(void){
	fprint(wctl, "resize -r %d %d %d %d",
		worig.x - Borderwidth,
		worig.y - Borderwidth,
		worig.x + blowup * 256 + Borderwidth,
		worig.y + blowup * 256 + Borderwidth);
	getwindow(display, Refnone);
}
int
drag(void){/* are you russian or are you dragon? */
	vlong n;
	n = nsec();
	if(nextfx - n < 𝅘𝅥𝅱)
		return 0;
	if(nextframe - n >= 2000000)
		sleep((nextframe - n) / 1000000 - 1);
	nextframe += 𝅘𝅥𝅱;
	return 1;
}
int
blat(void){
	uchar *p, *q;
	int i, j;
	q = pixels;
	r = screen->r;
	while(r.min.y < screen->r.max.y){
		r.max.y = r.min.y + blowup;
		p = blatbuf;
		for(i = 0; i < 256; i++, q++)
			for(j = 0; j < blowup; j++)
				*p++ = *q;
		loadimage(scanline[grey], scanline[grey]->r, blatbuf, i * blowup);
		draw(screen, r, scanline[grey], nil, ZP);
		r.min.y = r.max.y;
	}
	flushimage(display, 1);
	return drag();
}
void
gauss(void){
	int i;
	uchar *last;
	if(pixels == pxbuf){
		pixels = pxbuf + 0x10000;
		last = pxbuf;
	}else{
		last = pxbuf + 0x10000;
		pixels = pxbuf;
	}
	for(i = 0; i < 257; i++){
		pixels[i] = last[i];
		pixels[i + 0xfeff] = last[i + 0xfeff];
	}
	for(; i < 0xfeff; i++)
		pixels[i] = (last[i] << 2)
			+ (last[i - 256] + last[i + 1] + last[i + 256] + last[i - 1] << 1)
			+ last[i - 255] + last[i + 257] + last[i + 255] + last[i - 257] >> 4;
}
void
drip(void){
	Rectangle r;
	r.min.y = 9999;
	do{
		draw(screen, r, display->black, peter, ZP);
		if(r.min.y > screen->r.max.y){
			fprint(wctl, "resize -minx %d -dx 100 -dy 9999", nrand(xmax - 100));
			getwindow(display, Refnone);
			draw(screen, screen->r, display->black, nil, ZP);
			r = rectaddpt(Rect(-2, -96, 94, 0), screen->r.min);
			pixels[0] = r.min.x;
			loadimage(px, px->r, pixels, 1);
		}
		r.min.y += 36;
		r.max.y += 36;
		draw(screen, r, px, peter, ZP);
		flushimage(display, 1);
	}while(drag());
	centre();
}
void
zip(void){
	Rectangle r;
	r.max.x = -1;
	do{
		draw(screen, r, display->black, peter, ZP);
		if(r.max.x < 0){
			fprint(wctl, "resize -miny %d -dx 9999 -dy 100", nrand(ymax - 100));
			getwindow(display, Refnone);
			draw(screen, screen->r, display->black, nil, ZP);
			r = rectaddpt(Rect(0, -98, 96, 2), screen->r.max);
			pixels[0] = r.min.y;
			loadimage(px, px->r, pixels, 1);
		}
		r.min.x -= 50;
		r.max.x -= 50;
		draw(screen, r, px, peter, ZP);
		flushimage(display, 1);
	}while(drag());
	centre();
}
void
hmv(int dir){
	static int n, t, adj[16];
	int a, i;
	for(a = i = 0; i < 15; i++){
		a += adj[i] << i;
		adj[i] = adj[i + 1];
	}
	a += adj[15] << 15;
	if(pjwpx[n] + (a >> 15) < 128){
		pixels[n] = 144;
		adj[15] = pjwpx[n];
	}else{
		pixels[n] = 0;
		adj[15] = pjwpx[n] - 255;
	}
	if(!(++t & 127))
		blat();
	switch(dir){
	case ↑: n -= 256; break;
	case →: n++; break;
	case ↓: n += 256; break;
	case ←: n--; break;
	}
}
void
hlv(int lvl, int dir){
	if(--lvl)
		switch(dir){
		case ↑:
			hlv(lvl, ←);
			hmv(↓);
			hlv(lvl, ↑);
			hmv(→);
			hlv(lvl, ↑);
			hmv(↑);
			hlv(lvl, →);
			break;
		case →:
			hlv(lvl, ↓);
			hmv(←);
			hlv(lvl, →);
			hmv(↑);
			hlv(lvl, →);
			hmv(→);
			hlv(lvl, ↑);
			break;
		case ↓:
			hlv(lvl, →);
			hmv(↑);
			hlv(lvl, ↓);
			hmv(←);
			hlv(lvl, ↓);
			hmv(↓);
			hlv(lvl, ←);
			break;
		case ←:
			hlv(lvl, ↑);
			hmv(→);
			hlv(lvl, ←);
			hmv(↓);
			hlv(lvl, ←);
			hmv(←);
			hlv(lvl, ↓);
			break;
		}
	else
		switch(dir){
		case ↑:
			hmv(↓);
			hmv(→);
			hmv(↑);
			break;
		case →:
			hmv(←);
			hmv(↑);
			hmv(→);
			break;
		case ↓:
			hmv(↑);
			hmv(←);
			hmv(↓);
			break;
		case ←:
			hmv(→);
			hmv(↓);
			hmv(←);
			break;
		}
}
void
hilbert(void){
	int i, j, k;
	draw(screen, screen->r, display->black, nil, ZP);
	r = rectaddpt(Rect(0, 0, blowup, blowup), screen->r.min);
	hlv(8, ↑);
	for(i = 2; i < 386; i += 6){
		for(j = 0; j < 0x10000; j++)
			pixels[j] ^= i;
		blat(); blat();
	}
	for(i = 0; i < 256; i++){
		for(j = 0; j < 0x10000; j += 256){
			for(k = 255; k > 1; k--)
				pixels[j | k] = pixels[j | k - 2];
			pixels[j] = pixels[j | 1] = 0;
			j += 256;
			for(k = 0; k < 254; k++)
				pixels[j | k] = pixels[j | k + 2];
			pixels[j | 254] = pixels[j | 255] = 0;
		}
		blat();
	}
}
void
moire(void){
	double s0, c0, s1, c1, s2, c2;
	int x, y;
	s0 = s1 = s2 = 100.0;
	c0 = c1 = c2 = 0.0;
	do{
		for(x = 0; x < 256; x++)
			for(y = 0; y < 256; y++)
				pixels[y << 8 | x] =
					((int)sqrt((x - 128 - s0) * (x - 128 - s0) + (y - 128 - s1) * (y - 128 - s1))
					^ (int)sqrt((x - 128 - s1) * (x - 128 - s1) + (y - 128 - s2) * (y - 128 - s2))
					^ (int)sqrt((x - 128 - c2) * (x - 128 - c2) + (y - 128 - s0) * (y - 128 - s0))) & 4;
		for(y = 0; y < 48; y++)
			for(x = 0; x < 48; x++)
				if(facebits[3 * y + x / 16] << (x & 15) & 0x8000){
					pixels[y + 104 + (int)s1 << 8 | x + 104 + (int)s0] = 249;
					pixels[y + 104 + (int)s2 << 8 | x + 104 + (int)s1] = 251;
					pixels[y + 104 + (int)s0 << 8 | x + 104 + (int)c2] = 253;
				}
		s0 -= 0.1 * c0;
		c0 += 0.1 * s0;
		s1 -= 0.06 * c1;
		c1 += 0.06 * s1;
		s2 -= 0.08 * c2;
		c2 += 0.08 * s2;
	}while(blat());
}
void
rz(void){
	double s, c, ys, yc, xs, xc;
	int x, y, u, v;
	uchar *p;
	c = 0.0;
	s = 0.7;
	yc = 0.0;
	ys = 128.0;
	do{
		for(x = 0; x < 256; x++)
			for(y = 0; y < 256; y++){
				u = (int)(((x + yc) * c - (y + ys) * s) * (s + 2)) & 0xff;
				v = (int)(((x + yc) * s + (y + ys) * c) * (s + 2)) & 0xff;
				pixels[y << 8 | x] = pjwpx[v << 8 | u];
			}
		s -= 0.03 * c;
		c += 0.03 * s;
		ys -= 0.04 * yc;
		yc += 0.04 * ys;
	}while(blat());
}
void
rain(void){
	short buf[2][0x10000];
	int which, i;
	for(i = 0; i < 0x10000; i++)
		buf[0][i] = buf[1][i] = 0;
	for(which = 0; which <= 64; which++){
		for(i = 0; i < 0x10000; i++)
			pixels[i] = pjwpx[i] * which >> 6;
		blat();
	}
	which = 0;
	do{
		buf[which][lrand() & 0xffff] = 400;
		for(i = 256; i < 0xff00; i++){
			buf[!which][i] = (buf[which][i - 256] + buf[which][i + 256]
				+ buf[which][i - 1] + buf[which][i + 1] >> 1) - buf[!which][i];
			buf[!which][i] -= buf[!which][i] >> 6;
		}
		which = !which;
		for(i = 256; i < 0xff00; i++)
			pixels[i] = pjwpx[
				i + (buf[which][i - 256] - buf[which][i + 256] << 8) & 0xff00
				| i + buf[which][i - 1] - buf[which][i + 1] & 255
			];
	}while(blat());
}
void
tunnel(int headfirst){
	static double xs, xc = 64.0, ys, yc = 64.0;
	uchar a[384 * 384], d[384 * 384];
	int x, y, u, v, t;
	for(y = 0; y < 384; y++)
		for(x = 0; x < 384; x++){
			a[y * 384 + x] = atan2(x - 192, y - 192) * 256.0 / PI;
			d[y * 384 + x] = (24 * 192) / (sqrt((x - 192) * (x - 192) + (y - 192) * (y - 192)) + 0.00001);
		}
	t = 0;
	do{
		for(y = 0; y < 256; y++)
			for(x = 0; x < 256; x++){
				u = d[(y + 64 + (int)ys) * 384 + 64 + x + (int)xs] + t & 255;
				v = a[(y + 64 + (int)ys) * 384 + 64 + x + (int)xs] + t & 255;
				pixels[y << 8 | x] = pjwpx[headfirst ? u << 8 | v : v << 8 | u];
			}
		t += 6;
		xs -= 0.02 * xc;
		xc += 0.02 * xs;
		ys -= 0.04 * yc;
		yc += 0.04 * ys;
	}while(blat());
}
int
texel(int dim, int u, int v){
	if(u < 0 || u >= dim || v < 0 || v >= dim)
		return 1;
	return u * dim + v;
}
void
▲(uchar *tex, int dim, double d,
	double x0, double y0, double z0, double u0, double v0,
	double x1, double y1, double z1, double u1, double v1,
	double x2, double y2, double z2, double u2, double v2){
	double zz, x[2], z[2], u[2], v[2], xstep[2], zstep[2], ustep[2], vstep[2];
	uchar *row;
	int col, i, y, ystop, bender;
	if(x0 * ((y1 - y0) * (z2 - z0) - (z1 - z0) * (y2 - y0))
	+ y0 * ((z1 - z0) * (x2 - x0) - (x1 - x0) * (z2 - z0))
	+ (z0 + d) * ((x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)) >= 0.0)
		return;
	z0 = 1.0 / (z0 + d);
	x0 = 128.0 + 128.0 * x0 * z0;
	y0 = 128.0 - 128.0 * y0 * z0;
	u0 *= z0;
	v0 *= z0;
	z1 = 1.0 / (z1 + d);
	x1 = 128.0 + 128.0 * x1 * z1;
	y1 = 128.0 - 128.0 * y1 * z1;
	u1 *= z1;
	v1 *= z1;
	z2 = 1.0 / (z2 + d);
	x2 = 128.0 + 128.0 * x2 * z2;
	y2 = 128.0 - 128.0 * y2 * z2;
	u2 *= z2;
	v2 *= z2;
	if(y0 > y1){
		d = x0, x0 = x1, x1 = d;
		d = y0, y0 = y1, y1 = d;
		d = z0, z0 = z1, z1 = d;
		d = u0, u0 = u1, u1 = d;
		d = v0, v0 = v1, v1 = d;
	}
	if(y1 > y2){
		d = x1, x1 = x2, x2 = d;
		d = y1, y1 = y2, y2 = d;
		d = z1, z1 = z2, z2 = d;
		d = u1, u1 = u2, u2 = d;
		d = v1, v1 = v2, v2 = d;
	}
	if(y0 > y1){
		d = x0, x0 = x1, x1 = d;
		d = y0, y0 = y1, y1 = d;
		d = z0, z0 = z1, z1 = d;
		d = u0, u0 = u1, u1 = d;
		d = v0, v0 = v1, v1 = d;
	}
	bender = (y1 - y0) * (x2 - x0) < (x1 - x0) * (y2 - y0);
	x[!bender] = x0;
	z[!bender] = z0;
	u[!bender] = u0;
	v[!bender] = v0;
	d = 1.0 / (y2 - y0);
	xstep[!bender] = (x2 - x0) * d;
	zstep[!bender] = (z2 - z0) * d;
	ustep[!bender] = (u2 - u0) * d;
	vstep[!bender] = (v2 - v0) * d;
	y = y0;
	if(y < 0 || y > 255)
		return;
	row = pixels + y * 256;
	ystop = y1;
	if(y < ystop){
		x[bender] = x0;
		z[bender] = z0;
		u[bender] = u0;
		v[bender] = v0;
		d = 1.0 / (y1 - y0);
		xstep[bender] = (x1 - x0) * d;
		zstep[bender] = (z1 - z0) * d;
		ustep[bender] = (u1 - u0) * d;
		vstep[bender] = (v1 - v0) * d;
	}
	while(y < 256){
		if(y >= ystop){
			ystop = y2 + 1;
			if(y >= ystop)
				break;
			x[bender] = x1;
			z[bender] = z1;
			u[bender] = u1;
			v[bender] = v1;
			d = y2 == y1 ? 0 : 1.0 / (y2 - y1);
			xstep[bender] = (x2 - x1) * d;
			zstep[bender] = (z2 - z1) * d;
			ustep[bender] = (u2 - u1) * d;
			vstep[bender] = (v2 - v1) * d;
		}
		col = x[0];
		if(col == (int)x[1])
			row[col] = tex[texel(dim, u[0] / z[0], v[0] / z[0])];
		else{
			d = 1.0 / (x[1] - x[0]);
			for(i = 0; col + i <= x[1]; i++){
				zz = z[0] + d * i * (z[1] - z[0]);
				if(zz != 0)
					zz = dim / zz;
				row[col + i] = tex[texel(dim,
					(u[0] + (u[1] - u[0]) * d * i) * zz,
					(v[0] + (v[1] - v[0]) * d * i) * zz)];
			}
		}
		y++;
		row += 256;
		x[0] += xstep[0];
		z[0] += zstep[0];
		u[0] += ustep[0];
		v[0] += vstep[0];
		x[1] += xstep[1];
		z[1] += zstep[1];
		u[1] += ustep[1];
		v[1] += vstep[1];
	}
}
void
⬟(uchar *tex, int dim, double d, double *v0, double *v1, double *v2, double *v3, double *v4){
		▲(tex, dim, d,
			v0[0], v0[1], v0[2], 0.0, 0.557536515835,
			v1[0], v1[1], v1[2], 0.284079043841, 0.0,
			v2[0], v2[1], v2[2], 0.902113032588, 0.0978869674116);
		▲(tex, dim, d,
			v0[0], v0[1], v0[2], 0.0, 0.557536515835,
			v2[0], v2[1], v2[2], 0.902113032588, 0.0978869674116,
			v3[0], v3[1], v3[2], 1.0, 0.715920956159);
		▲(tex, dim, d,
			v0[0], v0[1], v0[2], 0.0, 0.557536515835,
			v3[0], v3[1], v3[2], 1.0, 0.715920956159,
			v4[0], v4[1], v4[2], 0.442463484165, 1.0);
}
#define φ 1.61803398875
#define φ⁻¹ 0.61803398875
double v4[12] = {-1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, 1};
double v6[24] = {1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1};
double v8[18] = {0, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 0, 0, 1, 0, 0, -1, 0};
double v12[60] = {
	-1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1,
	0, -φ⁻¹, -φ, 0, φ⁻¹, -φ, 0, φ⁻¹, φ, 0, -φ⁻¹, φ,
	-φ⁻¹, -φ, 0, -φ⁻¹, φ, 0, φ⁻¹, φ, 0, φ⁻¹, -φ, 0,
	-φ, 0, -φ⁻¹, -φ, 0, φ⁻¹, φ, 0, φ⁻¹, φ, 0, -φ⁻¹
};
double v20[36] = {
	0, -φ, 1, 0, φ, 1, 0, φ, -1, 0, -φ, -1,
	1, 0, φ, -1, 0, φ, -1, 0, -φ, 1, 0, -φ,
	φ, 1, 0, -φ, 1, 0, -φ, -1, 0, φ, -1, 0
};
void
d12(void){
	double v[60], x, y, z, d, xs, xc, ys, yc, zs, zc;
	int i;
	xs = ys = zs = 1.0;
	xc = yc = zc = 0.0;
	d = 600.0;
	do{
		for(i = 0; i < 0x10000; i++)
			pixels[i] = 0;
		for(i = 0; i < 60; i += 3){
			y = v12[i + 1] * xc + v12[i + 2] * xs;
			z = v12[i + 2] * xc - v12[i + 1] * xs;
			v[i + 2] = v12[i + 0] * ys + z * yc;
			z = v12[i + 0] * yc - z * ys;
			v[i + 0] = z * zc + y * zs;
			v[i + 1] = y * zc - z * zs;
		}
		d *= d > 3.0 ? 0.98 : 0.99999;
		⬟(d12face + 0 * 48 * 48, 48, d, v + 3, v + 39, v + 42, v + 6, v + 27);
		⬟(d12face + 1 * 48 * 48, 48, d, v + 42, v + 18, v + 54, v + 57, v + 6);
		⬟(d12face + 2 * 48 * 48, 48, d, v + 54, v + 18, v + 30, v + 33, v + 21);
		⬟(d12face + 3 * 48 * 48, 48, d, v + 33, v + 12, v + 36, v + 45, v + 21);
		⬟(d12face + 4 * 48 * 48, 48, d, v + 12, v + 51, v + 48, v + 0, v + 36);
		⬟(d12face + 5 * 48 * 48, 48, d, v + 0, v + 24, v + 9, v + 45, v + 36);
		⬟(d12face + 6 * 48 * 48, 48, d, v + 9, v + 24, v + 27, v + 6, v + 57);
		⬟(d12face + 7 * 48 * 48, 48, d, v + 57, v + 54, v + 21, v + 45, v + 9);
		⬟(d12face + 8 * 48 * 48, 48, d, v + 30, v + 18, v + 42, v + 39, v + 15);
		⬟(d12face + 9 * 48 * 48, 48, d, v + 15, v + 39, v + 3, v + 48, v + 51);
		⬟(d12face + 10 * 48 * 48, 48, d, v + 33, v + 30, v + 15, v + 51, v + 12);
		⬟(d12face + 11 * 48 * 48, 48, d, v + 0, v + 48, v + 3, v + 27, v + 24);
		xs -= 0.035 * xc;
		xc += 0.035 * xs;
		ys -= 0.051 * yc;
		yc += 0.051 * ys;
		zs -= 0.045 * zc;
		zc += 0.045 * zs;
	}while(blat());
}
void
plato(int solid){
	double *v0[5] = {v4, v6, v8, v12, v20}, v[60];
	double x, y, z, d, xs, xc, ys, yc, zs, zc, ds, dc;
	int n[5] = {12, 24, 18, 60, 36}, i;
	xs = ys = zs = 1.0;
	ds = 4.3;
	xc = yc = zc = dc = 0.0;
	do{
		for(i = 0; i < 0x10000; i++)
			pixels[i] = 0;
		for(i = 0; i < n[solid]; i += 3){
			y = v0[solid][i + 1] * xc + v0[solid][i + 2] * xs;
			z = v0[solid][i + 2] * xc - v0[solid][i + 1] * xs;
			d = v0[solid][i + 0] * yc - z * ys;
			z = v0[solid][i + 0] * ys + z * yc;
			x = d * zc + y * zs;
			y = y * zc - d * zs;
			v[i + 0] = x;
			v[i + 1] = y;
			v[i + 2] = z;
		}
		d = 7 + ds - (solid == 2);
		switch(solid){
		case 0:
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[3], v[4], v[5], -0.5, 0.5, v[9], v[10], v[11], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[3], v[4], v[5], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[9], v[10], v[11], -0.5, 0.5, v[6], v[7], v[8], 1, 0);
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[9], v[10], v[11], 1, 0);
			break;
		case 1:
			▲(pjwpx, 256, d, v[12], v[13], v[14], 0, 1, v[15], v[16], v[17], 0, 0, v[18], v[19], v[20], 1, 0);
			▲(pjwpx, 256, d, v[12], v[13], v[14], 0, 1, v[18], v[19], v[20], 1, 0, v[21], v[22], v[23], 1, 1);
			▲(pjwpx, 256, d, v[9], v[10], v[11], 0, 1, v[6], v[7], v[8], 0, 0, v[3], v[4], v[5], 1, 0);
			▲(pjwpx, 256, d, v[9], v[10], v[11], 0, 1, v[3], v[4], v[5], 1, 0, v[0], v[1], v[2], 1, 1);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 0, 1, v[18], v[19], v[20], 0, 0, v[6], v[7], v[8], 1, 0);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 0, 1, v[6], v[7], v[8], 1, 0, v[9], v[10], v[11], 1, 1);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 0, 1, v[3], v[4], v[5], 0, 0, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 0, 1, v[15], v[16], v[17], 1, 0, v[12], v[13], v[14], 1, 1);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 0, 1, v[9], v[10], v[11], 0, 0, v[0], v[1], v[2], 1, 0);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 0, 1, v[0], v[1], v[2], 1, 0, v[12], v[13], v[14], 1, 1);
			▲(pjwpx, 256, d, v[6], v[7], v[8], 0, 1, v[18], v[19], v[20], 0, 0, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[6], v[7], v[8], 0, 1, v[15], v[16], v[17], 1, 0, v[3], v[4], v[5], 1, 1);
			break;
		case 2:
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[9], v[10], v[11], -0.5, 0.5, v[12], v[13], v[14], 1, 0);
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[15], v[16], v[17], -0.5, 0.5, v[9], v[10], v[11], 1, 0);
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[12], v[13], v[14], -0.5, 0.5, v[6], v[7], v[8], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[12], v[13], v[14], -0.5, 0.5, v[9], v[10], v[11], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[9], v[10], v[11], -0.5, 0.5, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[15], v[16], v[17], -0.5, 0.5, v[6], v[7], v[8], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[12], v[13], v[14], 1, 0);
			break;
		case 3:
			⬟(pjwpx, 256, d, v + 3, v + 39, v + 42, v + 6, v + 27);
			⬟(pjwpx, 256, d, v + 42, v + 18, v + 54, v + 57, v + 6);
			⬟(pjwpx, 256, d, v + 54, v + 18, v + 30, v + 33, v + 21);
			⬟(pjwpx, 256, d, v + 33, v + 12, v + 36, v + 45, v + 21);
			⬟(pjwpx, 256, d, v + 12, v + 51, v + 48, v + 0, v + 36);
			⬟(pjwpx, 256, d, v + 0, v + 24, v + 9, v + 45, v + 36);
			⬟(pjwpx, 256, d, v + 9, v + 24, v + 27, v + 6, v + 57);
			⬟(pjwpx, 256, d, v + 57, v + 54, v + 21, v + 45, v + 9);
			⬟(pjwpx, 256, d, v + 30, v + 18, v + 42, v + 39, v + 15);
			⬟(pjwpx, 256, d, v + 15, v + 39, v + 3, v + 48, v + 51);
			⬟(pjwpx, 256, d, v + 33, v + 30, v + 15, v + 51, v + 12);
			⬟(pjwpx, 256, d, v + 0, v + 48, v + 3, v + 27, v + 24);
			break;
		case 4:
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[12], v[13], v[14], -0.5, 0.5, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[12], v[13], v[14], 1, 1, v[3], v[4], v[5], -0.5, 0.5, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[27], v[28], v[29], 1, 1, v[15], v[16], v[17], -0.5, 0.5, v[3], v[4], v[5], 1, 0);
			▲(pjwpx, 256, d, v[27], v[28], v[29], 1, 1, v[30], v[31], v[32], -0.5, 0.5, v[15], v[16], v[17], 1, 0);
			▲(pjwpx, 256, d, v[15], v[16], v[17], 1, 1, v[30], v[31], v[32], -0.5, 0.5, v[0], v[1], v[2], 1, 0);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[24], v[25], v[26], 1, 0);
			▲(pjwpx, 256, d, v[21], v[22], v[23], 1, 1, v[24], v[25], v[26], -0.5, 0.5, v[33], v[34], v[35], 1, 0);
			▲(pjwpx, 256, d, v[33], v[34], v[35], 1, 1, v[9], v[10], v[11], -0.5, 0.5, v[21], v[22], v[23], 1, 0);
			▲(pjwpx, 256, d, v[9], v[10], v[11], 1, 1, v[18], v[19], v[20], -0.5, 0.5, v[21], v[22], v[23], 1, 0);
			▲(pjwpx, 256, d, v[18], v[19], v[20], 1, 1, v[6], v[7], v[8], -0.5, 0.5, v[21], v[22], v[23], 1, 0);
			▲(pjwpx, 256, d, v[0], v[1], v[2], 1, 1, v[33], v[34], v[35], -0.5, 0.5, v[12], v[13], v[14], 1, 0);
			▲(pjwpx, 256, d, v[33], v[34], v[35], 1, 1, v[24], v[25], v[26], -0.5, 0.5, v[12], v[13], v[14], 1, 0);
			▲(pjwpx, 256, d, v[24], v[25], v[26], 1, 1, v[3], v[4], v[5], -0.5, 0.5, v[12], v[13], v[14], 1, 0);
			▲(pjwpx, 256, d, v[3], v[4], v[5], 1, 1, v[24], v[25], v[26], -0.5, 0.5, v[6], v[7], v[8], 1, 0);
			▲(pjwpx, 256, d, v[6], v[7], v[8], 1, 1, v[27], v[28], v[29], -0.5, 0.5, v[3], v[4], v[5], 1, 0);
			▲(pjwpx, 256, d, v[6], v[7], v[8], 1, 1, v[18], v[19], v[20], -0.5, 0.5, v[27], v[28], v[29], 1, 0);
			▲(pjwpx, 256, d, v[18], v[19], v[20], 1, 1, v[30], v[31], v[32], -0.5, 0.5, v[27], v[28], v[29], 1, 0);
			▲(pjwpx, 256, d, v[18], v[19], v[20], 1, 1, v[9], v[10], v[11], -0.5, 0.5, v[30], v[31], v[32], 1, 0);
			▲(pjwpx, 256, d, v[9], v[10], v[11], 1, 1, v[0], v[1], v[2], -0.5, 0.5, v[30], v[31], v[32], 1, 0);
			▲(pjwpx, 256, d, v[9], v[10], v[11], 1, 1, v[33], v[34], v[35], -0.5, 0.5, v[0], v[1], v[2], 1, 0);
			break;
		}
		xs -= 0.05 * xc;
		xc += 0.05 * xs;
		ys -= 0.09 * yc;
		yc += 0.09 * ys;
		zs -= 0.06 * zc;
		zc += 0.06 * zs;
		ds -= 0.05 * dc;
		dc += 0.05 * ds;
		gauss();
	}while(blat());
}
void
march(void){
	int i, j, row, u, d, samp;
	uchar *p;
	pixels = pxbuf;
	p = pxbuf + 0x10000;
	for(i = 0; i < 0x10000; i++){
		p[i] = ~pjwpx[i];
		pixels[i] = 0;
	}
	row = 0x0101;
	do{
		for(u = i = 0; i < 0x10000; ){
			switch(p[i] >> 4 & 8 | p[i + 4] >> 5 & 4 | p[i + 1028] >> 6 & 2 | p[i + 1024] >> 7){
			default:
				pixels[i + 2] = pixels[i + 257] = pixels[i + 258] = pixels[i + 259]
				= pixels[i + 512] = pixels[i + 513] = pixels[i + 514] = pixels[i + 515]
				= pixels[i + 769] = pixels[i + 770] = pixels[i + 771] = 128;
				break;
			case 1: case 14:
				pixels[i + 2] = pixels[i + 257] = pixels[i + 258] = pixels[i + 259] = pixels[i + 513]
				= pixels[i + 514] = pixels[i + 515] = pixels[i + 770] = pixels[i + 771] = 128;
				pixels[i + 512] = pixels[i + 769] = 200;
				break;
			case 2: case 13:
				pixels[i + 2] = pixels[i + 257] = pixels[i + 258] = pixels[i + 259] = pixels[i + 512]
				= pixels[i + 513] = pixels[i + 514] = pixels[i + 515] = pixels[i + 769] = pixels[i + 770] = 128;
				pixels[i + 771] = 200;
				break;
			case 3: case 12:
				pixels[i + 2] = pixels[i + 257] = pixels[i + 258] = pixels[i + 259]
				= pixels[i + 769] = pixels[i + 770] = pixels[i + 771] = 128;
				pixels[i + 512] = pixels[i + 513] = pixels[i + 514] = pixels[i + 515] = 200;
				break;
			case 4: case 11:
				pixels[i + 257] = pixels[i + 258] = pixels[i + 512] = pixels[i + 513] = pixels[i + 514]
				= pixels[i + 515] = pixels[i + 769] = pixels[i + 770] = pixels[i + 771] = 128;
				pixels[i + 2] = pixels[i + 259] = 200;
				break;
			case 5:
				pixels[i + 258] = pixels[i + 259] = pixels[i + 513] = pixels[i + 514]
				= pixels[i + 515] = pixels[i + 769] = pixels[i + 770] = 128;
				pixels[i + 2] = pixels[i + 257] = pixels[i + 512] = pixels[i + 771] = 200;
				break;
			case 6: case 9:
				pixels[i + 257] = pixels[i + 259] = pixels[i + 512] = pixels[i + 513]
				= pixels[i + 515] = pixels[i + 769] = pixels[i + 771] = 128;
				pixels[i + 2] = pixels[i + 258] = pixels[i + 514] = pixels[i + 770] = 200;
				break;
			case 7: case 8:
				pixels[i + 258] = pixels[i + 259] = pixels[i + 513] = pixels[i + 514]
				= pixels[i + 515] = pixels[i + 769] = pixels[i + 770] = pixels[i + 771] = 128;
				pixels[i + 2] = pixels[i + 257] = pixels[i + 512] = 200;
				break;
			case 10:
				pixels[i + 257] = pixels[i + 258] = pixels[i + 513] = pixels[i + 514]
				= pixels[i + 515] = pixels[i + 770] = pixels[i + 771] = 128;
				pixels[i + 2] = pixels[i + 259] = pixels[i + 512] = pixels[i + 769] = 200;
				break;
			}
			i += 4;
			if((i & 255) == 0)
				i += 3 * 256;
		}
		for(j = row; j & 0x3fff; j++)
			p[j] = p[j - 256] + 63 * p[j] >> 6;
		switch(row){
		case 0x0101: row = 0x4001; break;
		case 0x4001: row = 0x8001; break;
		case 0x8001: row = 0xc001; break;
		case 0xc001: row = 0x0101; break;
		}
	}while(blat());
}
void
byanyothername(char *s){
	Point p[2];
	int θ, r, d, n;
	uchar i, magtab[4] = {0x00, 0x0f, 0xf0, 0xff};
	d = rand();
	n = nrand(15) + 1;
	draw(screen, screen->r, display->black, nil, ZP);
	p[θ = 0] = worig;
	for(i = 1; i; i++){
		θ += d;
		r = 128 * blowup * sin(n * θ);
		p[i & 1] = addpt(worig, Pt(r * sin(θ), r * cos(θ)));
		loadimage(kpx, kpx->r, &i, 1);
		line(screen, p[0], p[1], 0, 0, 0, kpx, ZP);
		if(i & 1){
			flushimage(display, 1);
			drag();
		}
	}
	if(s == nil){
		p[0].x = worig.x - 128;
		p[0].y = worig.y - 128;
		for(d = 0; d < 0x10000; d++)
			pixels[d] = ~pjwpx[d];
		for(d = 0; d < 0x10000; d += 256){
			loadimage(scanline[1], Rect(0, 0, 256, 1), pixels + d, 256);
			draw(screen, rectaddpt(Rect(0, 0, 256, 1), p[0]), px, scanline[1], ZP);
			p[0].y++;
			if((d & 0x0300) == 0x0300){
				flushimage(display, 1);
				drag();
			}
		}
		p[0].x = worig.x - 128 * blowup;
		p[1].x = worig.x + 128 * blowup;
		p[1].y = worig.y + 128 * blowup;
		while(p[0].y > worig.y - 128 * blowup){
			p[0].y = p[1].y - 4 * blowup;
			draw(screen, Rpt(p[0], p[1]), display->black, nil, ZP);
			flushimage(display, 1);
			drag();
			p[1].y = p[0].y;
		}
	}else{
		p[0].x = worig.x - 16 * strlen(s);
		p[0].y = worig.y - 32;
		while(*s){
			stringnbg(peter, ZP, display->white, ZP, vga№1, s++, 1, display->black, ZP);
			unloadimage(peter, Rect(0, 0, 8, 16), pjwpx, 16);
			for(d = 0; d < 256; d += 16){
				pixels[d] = pixels[d | 4] = pixels[d | 8] = pixels[d | 12]
					= magtab[pjwpx[d >> 4] >> 6];
				pixels[d | 1] = pixels[d | 5] = pixels[d | 9] = pixels[d | 13]
					= magtab[pjwpx[d >> 4] >> 4 & 3];
				pixels[d | 2] = pixels[d | 6] = pixels[d | 10] = pixels[d | 14]
					= magtab[pjwpx[d >> 4] >> 2 & 3];
				pixels[d | 3] = pixels[d | 7] = pixels[d | 11] = pixels[d | 15]
					= magtab[pjwpx[d >> 4] & 3];
			}
			loadimage(peter, Rect(0, 0, 32, 64), pixels, 256);
			draw(screen, rectaddpt(Rect(0, 0, 32, 64), p[0]), px, peter, ZP);
			p[0].x += 32;
			flushimage(display, 1);
			drag();
		}
	}
	flushimage(display, 1);
	while(drag())
		;
}
void
lens(void){
	double xs, xc, ys, yc, d;
	int x, y, u, v;
	uchar *l;
	pixels = pxbuf;
	l = pxbuf + 0x10000;
	xs = ys = 80.0;
	xc = yc = 0.0;
	for(y = 0; y <= 45; y++)
		for(x = 0; x <= 45; x++){
			if(x * x + y * y < 2025){
				d = 20.0 / sqrt(2425.0 - x * x - y * y) - 1.0;
				u = x * d;
				v = y * d;
			}else
				u = v = 0;
			l[(45 + y) * 90 + 45 + x] = v * 256 + u;
			l[(45 + y) * 90 + 45 - x] = v * 256 - u;
			l[(45 - y) * 90 + 45 + x] = -v * 256 + u;
			l[(45 - y) * 90 + 45 - x] = -v * 256 - u;
		}
	do{
		for(x = 0; x < 0x10000; x++)
			pixels[x] = pjwpx[x];
		for(y = 0; y < 90; y++)
			for(x = 0; x < 90; x++){
				u = x -45 + 128 + (int)xs & 0x00ff;
				v = y -45 + 128 + (int)ys << 8 & 0xff00;
				pixels[v | u] = pjwpx[v | u + l[y * 90 + x] & 255];
			}
		xs -= 0.07 * xc;
		xc += 0.07 * xs;
		ys -= 0.09 * yc;
		yc += 0.09 * ys;
	}while(blat());
}
void
slide(void){
	int i;
	uchar *last;
	for(i = 0xfbff; i < 0x10000; i++)
		pxbuf[i] = pxbuf[0x10000 | i] = 255;
	do{
		if(pixels == pxbuf){
			pixels = pxbuf + 0x10000;
			last = pxbuf;
		}else{
			last = pxbuf + 0x10000;
			pixels = pxbuf;
		}
		for(i = 0; i < 0xfbff; i++)
			pixels[i] = last[i + 256] + last[i + 512] + last[i + 769]+ last[i + 1025] >> 2;
	}while(blat());
}
void
spin(void){
	uchar *last;
	double s, c;
	int i, x, y, u, v;
	s = 0.0;
	c = 1.0;
	do{
		if(pixels == pxbuf){
			last = pxbuf;
			pixels = pxbuf + 0x10000;
		}else{
			pixels = pxbuf;
			last = pxbuf + 0x10000;
		}
		for(i = 0; i < 0x10000; i++){
			x = (i & 255) - 128;
			y = (i >> 8 & 255) - 128;
			u = (int)(128 + x * c - y * s) & 255;
			v = (int)(128 + y * c + x * s) << 8 & 0xff00;
			pixels[i] = last[u | v] + last[i] >> 1;
		}
		s -= 0.003 * c;
		c += 0.003 * s;
	}while(blat());
}
void
flamesdotgif(void){
	int i, y, p;
	double defs, defc;
	ulong r;
	uchar *c;
	defs = 80.0;
	defc = 0.0;
	for(i = 0; i < 2000; i++)
		for(r = lrand(); r >> 16; r >>= 1)
			pixels[r & 0xffff] = 255;
	gauss();
	c = pixels;
	pixels = c == pxbuf ? pxbuf + 0x10000 : pxbuf;
	for(i = 0; i < 0x10000; i++){
		pixels[i] = 0;
		c[i] >>= 2;
	}
	y = 0;
	do{
		for(i = 0x0200; i < 0xf400; i++)
			if(pjwpx[i] < defc + 8)
				pixels[i + 0x0800] = ~pjwpx[i];
		for(i = 1; i < 0xfdff; i++){
			p = pixels[i - 1] + pixels[i + 1] + pixels[i + 255] + pixels[i + 256]
				 + pixels[i + 257] + pixels[i + 511] + pixels[i + 512] + pixels[i + 513] >> 3;
			p -= c[y + i & 0xffff];
			pixels[i] = p < 0 ? 0 : p;
		}
		y += 255;
		defs -= 0.018 * defc;
		defc += 0.018 * defs;
	}while(blat());
}
void
main(int, char**){
	char bekindrewind[] = "resize -r ................................................";
	uchar magtab[] = {
		0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
		0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
	};
	int i, j, p[2];
	i = open("/dev/audio", OWRITE);
	if(i < 0) sysfatal("open: %r");
	if(pipe(p) < 0) sysfatal("pipe: %r");
	switch(fork()){
	case -1:
		sysfatal("fork: %r");
	case 0:
		dup(p[1], 0); dup(i, 1);
		close(p[0]); close(p[1]); close(i);
		execl("/bin/games/opl3", "opl3", "-r", "1000", nil);
		sysfatal("execl: %r");
	}
	close(p[1]);
	close(i);
	wctl = open("/dev/wctl", ORDWR);
	if(wctl < 0) sysfatal("open: %r");
	srand(truerand());
	i = open("pjw.bit", OREAD);
	if(i < 0) sysfatal("open: %r");
	if(initdraw(nil, nil, "𝐩𝐣𝐰") < 0) sysfatal("initdraw: %r");
	vga№1 = openfont(display, "/lib/font/bit/vga/unicode.font");
	if(vga№1 == nil) sysfatal("no vga? blasphemy!");
	peter = readimage(display, i, 0);
	if(peter == nil) sysfatal("readimage: %r");
	close(i);
	unloadimage(peter, peter->r, pjwpx, sizeof pjwpx);
	freeimage(peter);
	for(i = 0; i < sizeof d12face; i++)
		d12face[i] = facebits[i >> 4] << (i & 15) & 0x8000 ? lrand() & 0xcc : 253;
	for(i = 0; i < 48; i++)
		for(j = 0; j < 3; j++){
			pixels[24 * i + 4 * j] = pixels[24 * i + 4 * j + 12]
				= magtab[facebits[3 * i + j] >> 12];
			pixels[24 * i + 4 * j + 1] = pixels[24 * i + 4 * j + 13]
				= magtab[facebits[3 * i + j] >> 8 & 15];
			pixels[24 * i + 4 * j + 2] = pixels[24 * i + 4 * j + 14]
				= magtab[facebits[3 * i + j] >> 4 & 15];
			pixels[24 * i + 4 * j + 3] = pixels[24 * i + 4 * j + 15]
				= magtab[facebits[3 * i + j] & 15];
		}
	peter = imgalloc(96, 96, GREY1, 1, DNofill);
	loadimage(peter, peter->r, pixels, 24 * 48);
	px = imgalloc(1, 1, CMAP8, 1, DNofill);
	kpx = imgalloc(1, 1, GREY8, 1, DNofill);
	read(wctl, bekindrewind + 10, 48);
	write(wctl, "resize -r 0 0 9999 9999", 23);
	getwindow(display, Refnone);
	xmax = screen->r.max.x + Borderwidth;
	ymax = screen->r.max.y + Borderwidth;
	blowup = (xmax < ymax ? xmax : ymax) / 256;
	if(blowup == 0) sysfatal("not enough room in here to swing a cat");
	blatbuf = malloc(blowup << 8);
	if(blatbuf == nil) sysfatal("blah");
	scanline[0] = imgalloc(256 * blowup, 1, CMAP8, 1, DNofill);
	scanline[1] = imgalloc(256 * blowup, 1, GREY8, 1, DNofill);
	worig = Pt(xmax - blowup * 256 >> 1, ymax - blowup * 256 >> 1);
	centre();
	nextfx = nsec();
	write(p[0], ♪, sizeof ♪);
	nextframe = nextfx + 𝅘𝅥𝅱;
	nextfx += 𝅝 * 7 + 16 * 𝅘𝅥𝅱; d12();
	nextfx += 24 * 𝅘𝅥𝅱; while(blat());
	pixels = pxbuf + 0x10000;
	nextfx += 24 * 𝅘𝅥𝅱; while(blat());
	nextfx += 𝅝 * 8; grey = 1; rz();
	nextfx += 𝅝 * 8; grey = 0; march();
	nextfx += 𝅝 * 4; grey = 1; flamesdotgif();
	nextfx += 𝅝 * 4; grey = 0; flamesdotgif();
	nextfx += 𝅝 * 6; grey = 1; rain();
	nextfx += 𝅝 * 2; slide();
	nextfx += 𝅝 * 4; grey = 0; spin();
	nextfx += 𝅝 * 4; tunnel(0);
	nextfx += 𝅝 * 6; grey = 1; tunnel(0);
	nextfx += 𝅝 * 2; spin();
	nextfx += 𝅝 * 4; grey = 1; lens();
	nextfx += 𝅝 * 2; drip();
	nextfx += 𝅝 * 2; grey = 1; plato(0);
	nextfx += 𝅝 * 2; zip();
	nextfx += 𝅝 * 2; plato(1);
	nextfx += 𝅝 * 2; drip();
	nextfx += 𝅝 * 2; plato(2);
	nextfx += 𝅝 * 2; zip();
	nextfx += 𝅝 * 2; plato(3);
	nextfx += 𝅝 * 2; drip();
	nextfx += 𝅝 * 2; plato(4);
	nextfx += 𝅝 * 4; tunnel(1);
	nextfx += 𝅝 * 4; grey = 0; moire();
	nextfx += 𝅝 * 12; hilbert();
	write(wctl, "resize -r 0 0 9999 9999", 23);
	getwindow(display, Refnone);
	worig.x = screen->r.min.x + screen->r.max.x >> 1;
	worig.y = screen->r.min.y + screen->r.max.y >> 1;
	pixels[0] = 200;
	loadimage(px, px->r, pixels, 1);
	nextfx += 𝅝 * 4; byanyothername("");
	nextfx += 𝅝 * 4; byanyothername("");
	nextfx += 𝅝 * 4; byanyothername("");
	nextfx += 𝅝 * 4; byanyothername("greetz to 9front ppl!");
	nextfx += 𝅝 * 4; byanyothername("happy new year 2023");
	nextfx += 𝅝 * 4; byanyothername("from umbraticus");
	nextfx += 𝅝 * 4; byanyothername("keep up the good work!");
	nextfx += 𝅝 * 6; byanyothername(nil);
	write(wctl, bekindrewind, sizeof(bekindrewind));
	exits(nil);
}