X_eTaL documentation

Files

macro library lib/Ffi.xtlm: Ffi.xtlm -- the binding macro: a facade function written from the signature of a native function (docs/ffi-macro.md). Import: "ffi:" u_se< "Ffi" (xetal-x puts this directory on XETAL_PATH)
library extensions/audio/lib/Audio.xtl: Audio.xtl -- the facade of the audio extension: decode Ogg Vorbis, MP3 and WAV, play them on the sound device, read what is playing as arrays, and play arrays. Import: "au:" u_se< "Audio" Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). With XETAL_HEADLESS=1 (or XETAL_AUDIO=off) nothing sounds and playback advances a 60th of a second per au:w_indow (or au:p_layed) -- for tests. Each signature line is written out by the binding macro (lib/Ffi.xtlm).
library extensions/audio/demos/Instruments.xtl: Instruments.xtl -- the instruments of the synthesizer demos (synth.xtl, scope.xtl): music as arrays. An ordinary X_eTaL library beside them. Import: "in:" u_se< "Instruments"
program extensions/audio/demos/scope.xtl: A live oscilloscope: the synthesizer's music (Instruments.xtl) plays while a window draws the samples under the playhead -- the left channel above, the right below -- each frame, triggered on the left channel's rising zero crossing so a steady chord stands still. Run: just demo audio scope (q or close: quit)
library extensions/canvas/lib/Canvas.xtl: Canvas.xtl -- the facade of the canvas extension: a native window showing X_eTaL arrays as pixels, with keys, clicks and frame ticks back. Import: "cv:" u_se< "Canvas" Run with xetal-x, which links canvas and serves its windows on the main thread (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/audio/demos/spectrum.xtl: The music visualizer: an Ogg Vorbis (or MP3, WAV) file plays while X_eTaL turns what is playing into a spectrum and the spectrum into 16 spokes in a 3D window -- Rust decodes, plays and draws; the analysis and the picture's geometry are X_eTaL arrays. Run: just demo audio spectrum (Space: pause, j/k: back/on 5 s, q: quit) Another file: change the path below (Ogg Vorbis, MP3 or WAV).
library extensions/scene/lib/Scene.xtl: Scene.xtl -- the facade of the scene extension: retained 3D line and point scenes in a native window, patched by id, the mouse orbiting. Import: "sc:" u_se< "Scene" Run with xetal-x, which links scene and serves its windows on the main thread (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
library std/Stats.xtl: Stats: a small statistics library (a standard library, built into xetal). Import it with an alias of your choice: "s:" u_se< "Stats". It is a demo library, loaded only by that import: a small subset of X_eTaL-libraries' Statistics, which has much more (a program may use either). Names with l: are exported; names with h: are private to this file.
program extensions/audio/demos/synth.xtl: A synthesizer made of arrays: X_eTaL computes every sample of a little piece -- notes from equal temperament, harmonics, envelopes, chords, stereo (the instruments are in Instruments.xtl, beside this file) -- and the audio extension plays them as they are made. Run: just demo audio synth
program extensions/canvas/demos/life.xtl: Conway's Life in a native window: the board is an X_eTaL array, each generation one array expression, drawn by Rust with every frame. Run: just demo canvas life (Space: a new board; q or close: quit)
library extensions/clock/lib/Clock.xtl: Clock.xtl -- the facade of the clock extension: wall-clock and monotonic time, which X_eTaL does not have, for timestamps and timing. Import: "ck:" u_se< "Clock" Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/clock/demos/bridge-cost.xtl: What the text bridge costs (docs/bridge.md): calls per second, and Floats per second carried out and back (it uses hello too). Run: just demo clock bridge-cost
library extensions/hello/lib/Hello.xtl: Hello.xtl -- the facade of the hello extension, the smallest X_eTaL native extension: each function proves one thing about the boundary. Import: "hx:" u_se< "Hello" Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each line below is a native function's signature; the binding macro (lib/Ffi.xtlm, docs/ffi-macro.md) writes the facade function from it.
library extensions/digest/lib/Digest.xtl: Digest.xtl -- the facade of the digest extension: SHA-256 and CRC-32 of text and of files, to check that content is what it should be. Import: "dg:" u_se< "Digest" Files are named by paths under the working directory (or XETAL_DIGEST_ROOT), relative, with no .. Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/hello/demos/tour.xtl: A tour of the hello extension: X_eTaL arrays handed to Rust and back. Run: just demo hello tour (or: xetal-x --ext extensions/hello run demos/tour.xtl)
library extensions/http/lib/Http.xtl: Http.xtl -- the facade of the http extension: bounded HTTP GET, text from the web within size, time and redirect limits. Import: "ht:" u_se< "Http" Limits: XETAL_HTTP_MAX bytes (16 MiB), XETAL_HTTP_TIMEOUT seconds (30), 5 redirects; only http:// and https:// URLs. Downloads go under the working directory (or XETAL_HTTP_ROOT). Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/http/demos/quakes-live.xtl: Earthquakes of the past week, live: the USGS feed of magnitude 2.5 and up, fetched now (the network: run it only when you mean to), its SHA-256 shown, then the same report as quakes.xtl. Run: just live-quakes (from the repository root; pictures go to work/draw/)
library extensions/http/demos/Seismic.xtl: Seismic.xtl -- the earthquake report (quakes.xtl, quakes-live.xtl): a USGS feed CSV into SQLite, SQL to select and group, X_eTaL arrays to compute, pictures to see it. An ordinary X_eTaL library beside them (not Quakes.xtl: on a case-insensitive file system that is quakes.xtl). Import: "se:" u_se< "Seismic"
library extensions/sqlite/lib/Sqlite.xtl: Sqlite.xtl -- the facade of the sqlite extension: SQLite databases for X_eTaL (rusqlite, SQLite compiled in). Import: "sq:" u_se< "Sqlite" A database is named by its path, relative to the working directory (or XETAL_SQLITE_ROOT), or ":memory:" for one call's scratch database; each call opens it and closes it. Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/http/demos/quakes.xtl: Earthquakes of a week: the USGS feed of magnitude 2.5 and up, saved 2026-10-06 (demos/data/PROVENANCE.txt), checked against its SHA-256, into SQLite; SQL selects and groups, X_eTaL computes (the magnitude-frequency law), pictures show it. Run: just demo http quakes (pictures go to work/draw/; the live feed: just live-quakes)
library extensions/image/lib/Image.xtl: Image.xtl -- the facade of the image extension: PNG and JPEG files as Float arrays from 0 to 1, and back. Gray is h by w, color h by w by 3 (red, green, blue); alpha is dropped. Import: "im:" u_se< "Image" Files are named by paths under the working directory (or XETAL_IMAGE_ROOT), relative, with no .. Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/image/demos/photo-lab.xtl: The photo lab: a photo is an array. Buzz Aldrin on the Moon (Apollo 11, NASA, public domain: demos/data/PROVENANCE.txt) read as numbers; filters and edges by rotating the array (the Life idiom), a color toning by an inner product, and the SVD compressing it at several ranks -- the native code reads, writes and decomposes, X_eTaL does the rest. Pictures go to work/photo-lab/. Run: just demo image photo-lab
library extensions/linalg/lib/Linalg.xtl: Linalg.xtl -- the facade of the linalg extension: numerical linear algebra through nalgebra. Matrices are Float arrays (row by column); a right-hand side may be a vector or a matrix of columns. Import: "la:" u_se< "Linalg" Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/scene/demos/cube.xtl: A wireframe cube turning in a native 3D window: its corners and edges are X_eTaL arrays; Rust draws them. Run: just demo scene cube (drag to turn it; q or close: quit)
library extensions/scene/demos/Endless.xtl: Endless.xtl -- the endless world and its player, shared by the voxel demos that walk or fly in it (voxels-endless, voxels-fly, voxels-dig and those after): columns of 16 by 16 blocks made around the player and dropped behind it, each made over three frames so no frame waits long; the player -- walking, swimming, flying -- moving against them; and blocks dug out and placed, remembered as edits that every column is made with, so they stay when the player comes back. Import: "en:" u_se< "Endless"
library extensions/scene/demos/Voxels.xtl: Voxels.xtl -- voxel chunks as arrays, shared by the voxels-* demos (docs/voxels.md). A chunk is a 16 by 16 by 16 array of block numbers, indexed x (east), y (up), z (south); 0 is air. Import: "vx:" u_se< "Voxels" (Not voxels.xtl: on a case-insensitive file system a demo of that name would be this file -- ask E8.)
library extensions/scene/demos/Play.xtl: Play.xtl -- playing in the endless world (Endless.xtl), shared by the voxel demos that dig, build and pour water (voxels-dig, voxels-water and those after): a crosshair and a hotbar drawn over the view, the block under the crosshair dug out or one placed against it, and one frame of the game -- an event, the world's work, the player. Import: "pl:" u_se< "Play"
library extensions/scene/demos/Rubik.xtl: Rubik.xtl -- a Rubik's cube as arrays, for the voxel cube demos (voxels-rubik and after). The cube is its 54 stickers; each sticker is where it is -- its cubie's position x y z, each -1 0 or 1 -- and which way it faces, a unit normal. A turn rotates the stickers of one layer by a quarter turn; matching the rotated stickers against the stickers gives where each one goes, a permutation of 54, and turning the cube is selecting its colors by that permutation. Every position reached by turns is a real cube's. Import: "rb:" u_se< "Rubik"
library extensions/scene/demos/RubikPlay.xtl: RubikPlay.xtl -- playing the voxel Rubik's cube (Rubik.xtl) with buttons and keys, shared by voxels-rubik-buttons and voxels-rubik-solve: a row of labeled buttons drawn over the scene and found under a click, and turns queued and animated one after another -- each a quarter turn of one layer seen as it happens, the next starting as soon as it is done, so a press always answers at once. Import: "rp:" u_se< "RubikPlay"
program extensions/scene/demos/voxels-chunk.xtl: Voxels, 1: a chunk is an array. 16 by 16 by 16 block numbers built from a height field in a few array expressions -- grass, dirt, stone, water below a level, sand at its shore, one tree -- then counted, cut and seen from above. (docs/voxels.md; the next demos draw it.) Run: just demo scene voxels-chunk (pictures go to work/draw/)
program extensions/scene/demos/voxels-dig.xtl: Voxels, 10: digging and building in the endless world. A crosshair marks where you look; the block under it, within 5 blocks, is found by marching 100 points along the view ray (en:p_ick). Click it to dig it out; right-click to place a block of the kind chosen on the hotbar against it. Each change is an edit the world remembers (x y z and the block), and every column is made with its edits -- the edited one made again at once (and its neighbor, when the block is on their border), so walk away and come back and the hole is still there. Run: just demo scene voxels-dig click (or X) dig, right-click (or E) place, 1 to 7 choose the block (stone dirt grass sand wood leaves water), W A S D walk, Space jump, Shift run, F fly (Space up, Shift down), drag or the arrows to look, H back to the start, q quit
program extensions/scene/demos/voxels-endless.xtl: Voxels, 6: an endless world. Walk in any direction and it never ends: the land comes from value noise hashed from the coordinates (vx:h_eightsAt), so any column of 16 by 16 blocks can be made by itself and fits its neighbors; columns are made around the player as it walks -- the nearest missing one each frame -- and dropped behind it; fog hides the edge of what is made, and a curved horizon (scene lowers the world by d^2 / 2R) makes it look like a small planet. Collision asks the columns themselves. The world and the player are the library Endless.xtl, shared with voxels-fly: each column is made over three frames, so no frame waits long. Run: just demo scene voxels-endless W A S D walk, Shift run, Space jump (in water: swim up; at the surface: climb out onto a bank one block high), drag the mouse or the arrows to look, H: back to the start, q or close: quit
program extensions/scene/demos/voxels-faces.xtl: Voxels, 2: which faces to draw. A face shows where a solid block's neighbor is not solid: six rotations of the solid mask, each compared with the mask itself (the idiom of Life), give every exposed face of the chunk at once; the faces become a list, one row each: x y z direction block. Checked on shapes with known answers, then the chunk's faces drawn as outlines in a 3D window, turning. Run: just demo scene voxels-faces (drag to turn it; q or close: quit)
program extensions/scene/demos/voxels-fly.xtl: Voxels, 7: flying. The endless world of voxels-endless, now from the air: F switches between walking and flying. Flying moves level whatever you look at -- W forward, S back, A and D sideways -- Space rises and Shift sinks, with no gravity, the blocks still stopping you; so you can look down at the land as you cross it. F again drops you back to walking wherever you are. The columns are made ahead, one a frame, and dropped behind, under fog and a curved horizon. Run: just demo scene voxels-fly F fly or walk; flying: W A S D level, Space up, Shift down; walking: Space jump or swim up, Shift run; drag the mouse or the arrows to look, H: back to the start, q quit
program extensions/scene/demos/voxels-game.xtl: Voxels, 15: Gem Hunt. Ten gems are buried around the start, a few blocks under the surface; dig them out in three minutes. The first lies four blocks straight down from where you start; the others are scattered within a dozen blocks, deeper. Gems glow a little (12 where a lamp is 15), so a tunnel near one is lit -- and the corner of the screen says how far the nearest gem you have not found is. Everything from the voxel demos works: dig, place, lamps, water, night. G gives up and shows the score. The game is X_eTaL: the gems are edits, a find is a dig whose cell is a gem's, the clock is the frames (60 a second), the labels are scene's. Run: just demo scene voxels-game click (or X) dig, right-click (or E) place, 1 to 8 choose the block (8 a lamp), N night or day, W A S D walk, Space jump, F fly, drag or the arrows to look, G give up, H back to the start, q quit
program extensions/scene/demos/voxels-light.xtl: Voxels, 14: light. The endless world, lit: a face open to the sky is in full sunlight; under an overhang, beneath a tree's crown or down a tunnel the light fades, a step a block, as it spreads from the open air. A lamp (the hotbar's eighth block) glows: its light spreads the same way through the air around it. N turns day to night and back -- the sunlight and the sky go, the lamps stay -- by one number in scene, so nothing is worked out again. Each column's light is worked out as it is made (vx:c_olumnLight: sunlight by a scan down each column, then rounds of spreading), and again when an edit makes it again: dig a tunnel's roof open and the sun comes in. Run: just demo scene voxels-light click (or X) dig, right-click (or E) place, 1 to 8 choose the block (8 a lamp), N night or day, W A S D walk, Space jump, Shift run, F fly, drag or the arrows to look, H back to the start, q quit
program extensions/scene/demos/voxels-rubik-buttons.xtl: Voxels, 12: the Rubik's cube with buttons. Six buttons under the cube turn its top, right and front layers a quarter turn either way -- U and U' the top, R and R' the right, F and F' the front (a letter alone clockwise as you look at that face, with ' counterclockwise), which between them reach every position of the cube. Each press is animated, a quarter turn in 8 frames; presses made while a turn is under way wait their turn, so the cube answers at once and never drops one. The turns made are shown above the cube. Run: just demo scene voxels-rubik-buttons click a button, or the keys u r f (Shift for '), z undo the last turn, 0 solved again, drag to look around, q quit
program extensions/scene/demos/voxels-rubik-solve.xtl: Voxels, 13: the Rubik's cube solved. Scramble it, or turn it with the six buttons, then Solve: the cube's turns so far are handed to the Eigencube library (X_eTaL-libraries, at LIBRARIES_COMMIT), which holds the cube as 26 rotation matrices and solves it by search, stage by stage -- the first layer by plain search over the twelve turns, the middle and last layers over known move sequences (slot inserts, an edge flip, Sune, a corner cycle), which is what makes it fast enough (2 to 3 seconds; a hundred and some moves). Then Step through the solution a turn at a time, Back to undo one, or Play it through, every turn animated on the voxel cube. The two models are checked to agree (tests/rubik-eigencube.xtl). Run: just demo scene voxels-rubik-solve the buttons, or keys: u r f turn (Shift for '), Space scramble, Enter solve, n step, b back, p play or pause, 0 solved again, drag to look around, q quit
library /Users/mike/github/softwarewrighter/X_eTaL-extensions/work/libraries/libs/Eigencube/src/Eigencube.xtl: Eigencube: a Rubik's cube as rotation matrices, turned by matrix products and solved by search. A port of Steffen Smolka's eigencube.py (github.com/smolkaj/eigencube, MIT). Each of the 26 cubelets is the integer point c of {-1, 0, 1}^3 where it sits in the solved cube and carries a rotation matrix R: it sits now at R c. A quarter turn of the face with outward normal v moves the cubelets with v . (R c) > 0, multiplying R by one rotation matrix. A batch of cubes is one array, n by 26 by 3 by 3, so all twelve turns of every cube in a search are two matrix products. Import it with an alias of your choice: "ec:" u_se< "Eigencube". Put libs/Eigencube/src on XETAL_PATH ("just path"); the reference is libs/Eigencube/docs. Names with l: are exported; those under h: are private to this file.
program extensions/scene/demos/voxels-rubik-turn.xtl: Voxels, 9: a quarter turn, seen. One layer of the Rubik's cube -- 9 cubies, a "plane" -- turns a quarter revolution while the rest stays still: its cubies' bodies and stickers rotated a little more each frame (a rotation matrix, one inner product), then the cube's colors permuted once it is done. A scramble: twelve quarter turns, each on a different axis from the one before (the faces in the order U R F D L B, twice), the directions + + - - + - and then - + + + - +; a pause; then the same turns undone in reverse, back to solved. Run: just demo scene voxels-rubik-turn (drag to turn it; q quit)
program extensions/scene/demos/voxels-rubik.xtl: Voxels, 8: a Rubik's cube. 26 dark cubies with their colored stickers, drawn as voxels; the cube itself is arrays (Rubik.xtl): its 54 stickers, each where it is and which way it faces, and each of the twelve quarter turns a permutation of them, computed from the cube's geometry. This demo checks the turns -- each a permutation, four of one solved, a turn and its undoing solved, R U R' U' of order 6, R U of order 105, and U and R turning the right way -- and shows the solved cube, turning slowly; keys turn its faces. Run: just demo scene voxels-rubik u d r l f b turn a face clockwise (as you look at it), Shift with the letter counterclockwise, z undo (back to solved), Space a scramble (25 random turns), 0 reset, drag to look around, q quit
program extensions/scene/demos/voxels-solid.xtl: Voxels, 3: the chunk drawn solid. The same faces as voxels-faces, each now a filled quad -- its four corners from a 6 by 4 table by direction -- one object per kind of block; scene shades each by how it faces the light and hides the farther ones behind the nearer (a depth buffer), with a little fog. All the array work is X_eTaL's; Rust only draws. Run: just demo scene voxels-solid (drag to turn it; q or close: quit)
program extensions/scene/demos/voxels-walk.xtl: Voxels, 5: walking. The island of voxels-world, seen from inside it. The player is nine numbers -- x y z (feet), vx vy vz, yaw, pitch, on the ground -- and every frame X_eTaL reads the keys and the mouse, turns, falls, jumps, and moves one axis at a time against the solid blocks the player's box would overlap, stopping at the face of the block it hits (a swept box per axis, as the APL game collides); then it sets scene's first-person camera. It also tests the 32 chunks against the planes of the view, as the APL game culls (key c). Run: just demo scene voxels-walk (a new island each run; --seed 1) W A S D walk, Shift run, Space jump (in water: swim up; at the surface: climb out onto a bank one block high), drag the mouse or the arrows to look, c: the chunks in view, H: back to the start, q or close: quit
program extensions/scene/demos/voxels-water.xtl: Voxels, 11: water that flows. A stepped hill stands by the start with a lake on its top terrace, held in by a rim of grass. Dig into the rim and the lake spills out and runs down the steps like a waterfall; dig beside the sea and the hole fills. Water flows as a cellular automaton on the cells it has just reached (Endless.xtl): each tick a cell falls into the air below it, or, standing on something solid, spreads one level lower into the air at its sides, 7 levels from a source; the lake and the sea are sources that never empty. The cells it reaches are edits like any dug or placed block, so the water stays where it ran. Water is drawn translucent: the lake's floor and the seabed show through. Run: just demo scene voxels-water click (or X) dig, right-click (or E) place, 1 to 7 choose the block (7 is water, which flows), W A S D walk, Space jump, Shift run, F fly (Space up, Shift down), drag or the arrows to look, H back to the rim, q quit
program extensions/scene/demos/voxels-world.xtl: Voxels, 4: a world of chunks. An island 64 by 32 by 64 -- 32 chunks of 16 cubed -- from value noise made by linear algebra (random heights on grids every 16, 8 and 4 blocks, each interpolated as M G M'), shaped by the chunk's rules over the whole world at once, with trees planted by folding one tree over a list of places. Its faces are found over the whole array (so faces between chunks hide each other), then sent to scene chunk by chunk, each chunk's kinds of block under their own ids -- the ids a later demo patches when a block changes. Run: just demo scene voxels-world (drag to turn it; q or close: quit)
program extensions/sqlite/demos/notebook.xtl: The data notebook: a CSV in SQLite, SQL to select and group, X_eTaL arrays to compute, pictures to see it. Atmospheric CO2 at Mauna Loa, 1959-2025 (NOAA GML and Scripps; demos/data/PROVENANCE.txt). Run: just demo sqlite notebook (pictures go to work/draw/)
library extensions/web/lib/Web.xtl: Web.xtl -- the facade of the web extension: HTTP serving, where the program is the request loop. axum serves on 127.0.0.1 in the background and queues each request; the program takes the next one, reads its parts, and replies. Import: "wb:" u_se< "Web" Run with xetal-x (xetal-x --ext DIR puts this directory on XETAL_PATH). Each signature line is written out by the binding macro (lib/Ffi.xtlm).
program extensions/web/demos/life.xtl: A live page: Conway's Life kept by an X_eTaL program and drawn as SVG, one generation per request. The program is the server's request loop. Run: just demo web life, then open http://127.0.0.1:8470/ (New board, Glider; Quit ends the program)
program extensions/web/demos/todomvc.xtl: TodoMVC on the web: the todos live in SQLite, the X_eTaL program is the server -- it routes each request, keeps the filter, counts what is left, and writes the page; forms post and are redirected back. Run: just demo web todomvc, then open http://127.0.0.1:8470/ (the list is kept in work/todos.db; Quit ends the program)

Items

name	kind	type
ʰw̲ords	function	`Char -> Box Char`
ʰw̲ord	function	`Int -> Box a -> a`
ʰv̲alue	function	`Char -> Char -> Char`
ʰq̲uery	function	`Char -> Char -> Char`
ʰp̲ut	function	`Char -> Char -> Char`
ʰg̲et	function	`Char -> Char -> Char`
ʰp̲arams	function	`(Any a, Num b) => a -> b -> Char`
ʰp̲uts	function	`Box Char -> Char -> Char`
ᵐb̲ind<	macro	`Char -> Char -> Char`
ˡo̲pen	function	`Char -> Int`
ˡi̲nfo	function	`Num a => a -> Float`
ˡc̲hunk	function	`(Num a, Num b) => a -> b -> Float`
ˡp̲lay!	function	`Num a => a -> Int`
ˡp̲ause!	function	`Num a => a -> Int`
ˡs̲eek!	function	`(Num a, Num b) => a -> b -> Float`
ˡp̲osition	function	`Num a => a -> Float`
ˡw̲indow	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲tate	function	`Num a => a -> Int`
ˡc̲lose!	function	`Num a => a -> Int`
ˡo̲utput	function	`Num a => a -> Int`
ˡq̲ueue!	function	`(Num a, Num b) => a -> b -> Float`
ˡw̲ait!	function	`(Num a, Num b) => a -> b -> Float`
ˡp̲layed	function	`Num a => a -> Float`
ˡpackage	value	`Char`
ˡrate	value	`Float`
ˡh̲z	function	`Num a => a -> Float`
n	value	`Int`
t	value	`Float`
env	value	`Float`
ˡt̲one	function	`Float -> Float -> Float`
chords	value	`Int`
ˡb̲ar	function	`Int -> Float`
first	value	`Float`
blen	value	`Int`
ᵘm̲ore	function	`Float -> Float`
song	value	`Float`
left	value	`Float`
right	value	`Float`
total	value	`Float`
w	value	`Int`
v	value	`Int`
ᵘf̲eed	function	`Num a => a -> Int -> Int`
ᵘt̲race	function	`(Num a, Truthy a) => Float -> a`
ᵘt̲rigger	function	`Float -> Int -> Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`Int -> Int`
last	value	`Int`
ˡo̲pen!	function	`Num a => Char -> a -> Int`
ˡs̲how!	function	`(Num a, Num b) => a -> b -> Int`
ˡn̲ext!	function	`Num a => a -> Char`
ˡc̲lose!	function	`Num a => a -> Int`
ˡpackage	value	`Char`
a	value	`Int`
rate	value	`Float`
n	value	`Int`
f	value	`Float`
t	value	`Float`
x	value	`Float`
hann	value	`Float`
taper	value	`Float`
ᵘl̲oudness	function	`Float -> Float`
k	value	`Float`
th	value	`Float`
ang	value	`Float`
r0	value	`Float`
ᵘs̲pokes	function	`Float -> Float`
w	value	`Int`
c	value	`Int`
ᵘr̲ows	function	`a -> a`
g	value	`Float`
ring	value	`Int`
ᵘd̲raw	function	`Float -> Float`
p	value	`Int`
ᵘq̲uit	function	`Any a => a -> Float`
ᵘk̲ey	function	`Char -> Int`
ᵘf̲rame	function	`Float -> Float`
last	value	`Float`
ˡo̲pen!	function	`Num a => Char -> a -> Int`
ˡp̲olyline!	function	`(Num a, Num b) => a -> b -> Int`
ˡs̲egments!	function	`(Num a, Num b) => a -> b -> Int`
ˡd̲ots!	function	`(Num a, Num b) => a -> b -> Int`
ˡq̲uads!	function	`(Num a, Num b) => a -> b -> Int`
ˡf̲og!	function	`(Num a, Num b) => a -> b -> Int`
ˡe̲ye!	function	`(Num a, Num b) => a -> b -> Int`
ˡc̲urve!	function	`(Num a, Num b) => a -> b -> Int`
ˡd̲aylight!	function	`(Num a, Num b) => a -> b -> Int`
ˡs̲ky!	function	`(Num a, Num b) => a -> b -> Int`
ˡc̲ontrols	function	`Num a => a -> Float`
ˡo̲verlay!	function	`(Num a, Num b) => a -> b -> Int`
ˡl̲abel!	function	`Num a => a -> Char -> Int`
ˡr̲emove!	function	`(Num a, Num b) => a -> b -> Int`
ˡc̲amera!	function	`(Num a, Num b) => a -> b -> Int`
ˡn̲ext!	function	`Num a => a -> Char`
ˡc̲lose!	function	`Num a => a -> Int`
ˡpackage	value	`Char`
ˡm̲ean	function	`Num a => a -> Float`
ʰs̲quare	function	`Num a => a -> a`
ʰd̲eviations	function	`Num a => a -> Float`
ˡv̲ariance	function	`Num a => a -> Float`
ˡs̲d	function	`Num a => a -> Float`
ˡr̲ange	function	`Num a => a -> a`
v	value	`Int`
ᵘp̲lay	function	`Int -> Int`
last	value	`Int`
c	value	`Int`
ᵘl̲ife	function	`(Num a, Truthy a) => a -> a`
ᵘs̲eed	function	`Truthy a => Int -> a`
w	value	`Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`(Num a, Truthy a) => a -> a`
last	value	`Int`
ˡn̲ow	function	`Unit -> Float`
ˡi̲so	function	`Unit -> Char`
ˡi̲soOf	function	`Num a => a -> Char`
ˡm̲illis	function	`Unit -> Float`
ˡt̲ime	function	`(Any a, Any b) => (a -> b) -> a -> Float`
ˡpackage	value	`Char`
n	value	`Int`
ms	value	`Float`
v	value	`Float`
ms	value	`Float`
ˡa̲nswer	function	`Unit -> Int`
ˡa̲dd	function	`(Num a, Num b) => a -> b -> Float`
ˡs̲hout	function	`Char -> Char`
ˡs̲um	function	`Num a => a -> Float`
ˡe̲cho	function	`Num a => a -> Float`
ˡf̲ail	function	`Unit -> Int`
ˡp̲anic	function	`Unit -> Int`
ˡpackage	value	`Char`
ˡs̲ha256	function	`Char -> Char`
ˡs̲ha256File	function	`Char -> Char`
ˡc̲rc32	function	`Char -> Int`
ˡc̲rc32File	function	`Char -> Int`
ˡpackage	value	`Char`
t	value	`Int`
c	value	`Int`
ˡg̲et	function	`Char -> Char`
ˡs̲tatus	function	`Unit -> Int`
ˡh̲eader	function	`Char -> Char`
ˡs̲ave!	function	`Char -> Char -> Int`
ˡpackage	value	`Char`
url	value	`Char`
csv	value	`Char`
db	value	`Char`
ʰr̲ound	function	`Float -> Float`
ʰm̲ean	function	`Float -> Float`
ˡr̲eport	function	`Char -> Char`
ˡe̲xec	function	`Char -> Char -> Int`
ˡn̲ums	function	`Char -> Char -> Float`
ˡt̲exts	function	`Char -> Char -> Char`
ˡc̲ols	function	`Char -> Char -> Char`
ˡq̲uote	function	`Char -> Char`
ˡi̲mport	function	`Char -> Char -> Int`
ˡpackage	value	`Char`
csv	value	`Char`
ˡr̲ead	function	`Char -> Float`
ˡg̲ray	function	`Char -> Float`
ˡs̲ize	function	`Char -> Int`
ˡw̲rite!	function	`Num a => Char -> a -> Int`
ˡr̲esize	function	`(Num a, Num b) => a -> b -> Float`
ˡpackage	value	`Char`
src	value	`Char`
out	value	`Char`
ᵘr̲ound	function	`Float -> Float`
ᵘm̲ean	function	`Num a => a -> Float`
p	value	`Float`
box	value	`Float`
sharp	value	`Float`
sx	value	`Float`
sy	value	`Float`
gx	value	`Float`
gy	value	`Float`
edge	value	`Float`
n	value	`Int`
c	value	`Float`
sepia	value	`Float`
toned	value	`Float`
n	value	`Int`
u	value	`Float`
s	value	`Float`
v	value	`Float`
e	value	`Float`
ᵘr̲ank	function	`Int -> Float`
r5	value	`Float`
r20	value	`Float`
r50	value	`Float`
ᵘe̲rr	function	`Float -> Float`
n	value	`Int`
ˡs̲olve	function	`(Num a, Num b) => a -> b -> Float`
ˡi̲nverse	function	`Num a => a -> Float`
ˡd̲et	function	`Num a => a -> Float`
ˡl̲stsq	function	`(Num a, Num b) => a -> b -> Float`
ˡe̲ig	function	`Num a => a -> Float`
ˡe̲igVecs	function	`Num a => a -> Float`
ˡs̲vdS	function	`Num a => a -> Float`
ˡs̲vdU	function	`Num a => a -> Float`
ˡs̲vdV	function	`Num a => a -> Float`
ˡpackage	value	`Char`
c	value	`Int`
e	value	`Int`
w	value	`Int`
k	value	`Int`
x	value	`Int`
y	value	`Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`Num a => a -> a`
last	value	`Int`
ˡreach	value	`Int`
ˡp̲layer	function	`(Any a, Any b, Any c, Any d) => (a, b, c, d) -> a`
ˡp̲osition	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i) => ((a, b, c, d, e, f), g, h, i) -> a`
ˡk̲eys	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (a, (b, c, d, e, f, g, h, i), j, k) -> b`
ˡw̲orld	function	`(Any a, Any b, Any c, Any d) => (a, b, c, d) -> b`
ˡe̲dits	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (a, (b, c, d, e, f, g, h, i), j, k) -> f`
ˡe̲ye	function	`(Any a, Any b, Any c, Any d, Any e, Any f) => ((Float, a, Float, Float, b, c), d, e, f) -> Float`
ˡw̲indow	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => (a, b, c, (d, e, f, g, h)) -> d`
ˡs̲tart	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => (a, b, c, (d, e, f, g, h)) -> f`
ʰk̲ey	function	`Num a => a -> a`
ʰc̲x	function	`Int -> Int`
ʰc̲z	function	`Int -> Int`
ˡw̲ithPlayer	function	`(Any a, Any b, Any c, Any d, Any e) => a -> (b, c, d, e) -> (a, c, d, e)`
ˡn̲ew	function	`(Any a, Num b, Num c, Num d, Num e, Num f, Num g, Num h, Num i, Num j, Num k) => a -> ((Float, Float, Float, Float, Float, Float), (b, b, Box b, Box b, c, b, d, e), (f, g, h, b), (a, i, Float, j, k))`
ˡn̲ewAt	function	`(Any a, Num b, Num c, Num d, Num e, Num f, Num g, Num h, Num i, Num j, Num k) => a -> Float -> ((Float, Float, Float, Float, Float, Float), (b, b, Box b, Box b, c, b, d, e), (f, g, h, b), (a, i, Float, j, k))`
ʰh̲ome	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => ((Float, a, b, c, d, e), f, g, h) -> Int`
ʰt̲rim	function	`(Any a, Any b, Any c, Any d, Any e, Any h, Any i, Any j, Any k, Any l, Num m, Any n, Any o, Any p, Any q) => ((Float, a, b, c, d, e), (Int, Int, f, g, h, i, j, k), l, (m, n, o, p, q)) -> ((Float, a, b, c, d, e), (Int, Int, f, g, h, i, j, k), l, (m, n, o, p, q))`
ʰs̲endOne	function	`Int -> Int -> Int`
ˡs̲tream	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰw̲ait	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰb̲locks	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰr̲emake	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ˡe̲dited	function	`(Int, Int) -> Int -> Int`
ʰf̲aces	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰl̲ight	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰs̲end	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰc̲ell	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g, Num h, Truthy h) => (Int, a, Box b, c, d, e, f, g) -> Int -> h`
ˡh̲it	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g) => (Int, a, Box b, c, d, e, f, g) -> Float -> Float`
ˡp̲ick	function	`(Any a, Num b, Truthy b, Any c, Any d, Any e, Any f, Any g) => (Int, a, Box b, c, d, e, f, g) -> Float -> Int`
ˡs̲et	function	`(Any a, Any b, Any c) => (Int, Int) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c)`
ˡs̲etAll	function	`(Any a, Any b, Any c) => (Int, Int) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c)`
ˡp̲our	function	`(Any a, Any b, Any c) => Int -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c)`
ʰd̲isplace	function	`(Any a, Any b, Any c) => (Int, Int) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c) -> (a, (Int, Int, Box Int, Box Int, Int, Int, Int, Int), b, c)`
ˡl̲ook	function	`(Int, Int, Box Int, Box Int, Int, Int, Int, Int) -> Int -> Int`
ˡpace	value	`Int`
ˡfull	value	`Int`
ʰc̲ellKey	function	`Int -> Int`
ʰs̲hift	function	`Int -> Int -> Int`
ʰf̲low	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Num i) => ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i)) -> ((Float, a, b, c, d, e), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (f, Int, Int, Int), (Int, Int, g, h, i))`
ʰn̲ext	function	`(Truthy a, Num b) => a -> b -> Int`
ʰr̲efill	function	`(Int, Int, Box Int, Box Int, Int, Int, Int, Int) -> Int -> (Int, Int, Int)`
ʰf̲all	function	`(Int, Int, Box Int, Box Int, Int, Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)`
ʰs̲pread	function	`((Int, Int, Box Int, Box Int, Int, Int, Int, Int), Int) -> (Int, Int, Int) -> (Int, Int, Int)`
ʰd̲rawWater	function	`((Int, Int, Box Int, Box Int, Int, Int, Int, Int), Int) -> Int -> Int`
ʰq̲uads	function	`(Int, (Float, Float, Float), (Float, Float, Float), (Float, Float, Float), (Float, Float, Float)) -> Int -> Float`
ˡw̲ater	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (a, (b, c, d, e, f, g, h, i), j, k) -> h`
ˡa̲sleep	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Num i, Any j, Any k, Truthy l) => (a, (b, c, d, e, f, g, h, i), j, k) -> l`
ˡw̲aterUnits	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Num h, Any i, Any j, Any k) => (a, (b, c, d, e, f, g, h, i), j, k) -> h`
ˡo̲verlaps	function	`(Num a, Truthy b) => Float -> a -> b`
ˡdt	value	`Float`
ʰs̲et3	function	`Float -> Float -> Float`
ʰs̲nap	function	`Float -> Float -> Float`
ʰm̲x	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (Int, a, Box b, c, d, e, f, g) -> (Float, Float, h, i, j, k) -> (Float, Float, h, i, j, k)`
ʰm̲z	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => (Int, a, Box b, c, d, e, f, g) -> (Float, Float, h, i, j, k) -> (Float, Float, h, i, j, k)`
ʰm̲y	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j) => (Int, a, Box b, c, d, e, f, g) -> (Float, Float, h, i, Float, j) -> (Float, Float, h, i, Float, j)`
ˡm̲ove	function	`(Any a, Num b, Any c, Any d, Any e, Any f, Any g, Any h, Num i, Any j, Any k, Any l, Any m) => ((Float, Float, Float, Float, Float, Float), (Int, a, Box b, c, d, e, f, g), h, (i, j, k, l, m)) -> Float -> ((Float, Float, Float, Float, Float, Float), (Int, a, Box b, c, d, e, f, g), h, (i, j, k, l, m))`
ˡh̲omeAgain	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => (a, b, c, (d, e, f, g, h)) -> ((f, Float, Float, Float, Float, Float), b, c, (d, e, f, g, h))`
ˡt̲oggleFly	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => ((a, b, c, d, e, Float), f, g, h) -> ((a, Float, c, d, Float, Float), f, g, h)`
ˡs̲top	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Num i) => (a, b, c, (d, e, f, g, h)) -> (a, b, c, (d, e, f, i, h))`
ˡs̲topped	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Num g, Any h, Truthy i) => (a, b, c, (d, e, f, g, h)) -> i`
ˡl̲it	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => (a, b, c, (d, e, f, g, h)) -> h`
ˡl̲ighting	function	`(Any a, Any b, Any c, Num d, Any e, Any f, Any g, Any h, Num i) => (a, b, c, (d, e, f, g, h)) -> (a, b, c, (d, e, f, g, i))`
ˡn̲ight	function	`(Any a, Any b, Any c, Num d, Any e, Any f, Any g, Num h) => (a, b, c, (d, e, f, g, h)) -> (a, b, c, (d, e, f, g, h))`
ˡn	value	`Int`
ˡcells	value	`Int`
ˡair	value	`Int`
ˡstone	value	`Int`
ˡdirt	value	`Int`
ˡgrass	value	`Int`
ˡsand	value	`Int`
ˡwater	value	`Int`
ˡwood	value	`Int`
ˡleaves	value	`Int`
ˡlamp	value	`Int`
ˡgem	value	`Int`
ˡnames	value	`Char`
ˡglyphs	value	`Char`
i	value	`Int`
ˡxs	value	`Int`
ˡys	value	`Int`
ˡzs	value	`Int`
ˡh̲ills	function	`Float -> Int`
ˡc̲hunk	function	`(Num a, Truthy a) => Int -> a`
ˡc̲ounts	function	`(Num a, Truthy a) => Int -> a`
ˡs̲ide	function	`Int -> Int -> Char`
ˡc̲olumn	function	`a -> a`
ˡt̲op	function	`(Num a, Truthy a) => a -> a`
X	value	`Int`
Y	value	`Int`
Z	value	`Int`
ˡs̲olid	function	`(Num a, Num b, Truthy b) => a -> b`
ˡe̲xposed	function	`(Num a, Truthy b) => a -> b`
ˡs̲urface	function	`(Num a, Truthy b) => a -> b`
ʰr̲ows	function	`Int -> Int -> Int`
ˡf̲aces	function	`Int -> Int`
ˡc̲ount	function	`(Num a, Truthy a) => Int -> a`
ox	value	`Int`
oy	value	`Int`
oz	value	`Int`
ˡe̲dges	function	`Int -> Float`
ˡcolors	value	`Float`
cx	value	`Int`
cy	value	`Int`
cz	value	`Int`
ˡc̲orners	function	`Int -> Float`
ˡq̲uads	function	`Int -> Float`
ʰw̲eights	function	`Int -> Int -> Float`
ʰn̲oise	function	`Int -> Int -> Float`
ˡh̲eights	function	`Int -> Int`
ʰc̲oords	function	`Int -> Int`
ˡt̲errain	function	`(Num a, Truthy a) => Int -> a`
ˡt̲ree	function	`(Num a, Truthy a) => Int -> a -> a`
ˡw̲orldFaces	function	`Int -> Int`
ˡc̲hunkOf	function	`Int -> Int`
ˡf̲orest	function	`Int -> Int -> Int`
ˡh̲ash	function	`(Num a, Num b) => a -> b -> Float`
ʰw̲eight	function	`Num a => Float -> a -> Float`
ʰn̲oiseOf	function	`Num a => a -> Int -> Float`
ˡh̲eightsAt	function	`Int -> Int`
cell	value	`Int`
inner	value	`Int`
ˡp̲atch	function	`Int -> Box Int`
cc	value	`Int`
cx18	value	`Int`
cy18	value	`Int`
cz18	value	`Int`
X18	value	`Int`
Y18	value	`Int`
Z18	value	`Int`
own	value	`Int`
ˡc̲olumnBlocks	function	`Int -> Int`
ˡc̲olumnMask	function	`Num a => a -> Int`
ˡc̲olumnWater	function	`Num a => a -> Int`
ˡc̲olumnFaces	function	`Int -> Int -> Int`
ex0	value	`Int`
ex1	value	`Int`
ey0	value	`Int`
ey1	value	`Int`
ez0	value	`Int`
ez1	value	`Int`
ˡc̲olumnLight	function	`Num a => a -> (Int, Int)`
ʰg̲low	function	`Int -> Int -> Int`
ˡf̲aceLight	function	`(Num a, Truthy a) => (Int, (a, a)) -> Int -> a`
ˡkinds	value	`Int`
ˡkindsLit	value	`Int`
ʰk̲inds	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Num h) => (a, b, c, (d, e, f, g, h)) -> Int`
ˡhelp	value	`Char`
ˡhelpLit	value	`Char`
ˡh̲ud	function	`Num a => a -> Int -> Int`
ˡh̲udLit	function	`Num a => a -> Int -> Int`
ʰh̲udOf	function	`Num a => (a, Int) -> Int -> Int`
ˡd̲ig	function	`(Any a, Any b, Any c, Num d, Any e, Any f) => ((Float, a, Float, Float, b, c), (Int, Int, Box Int, Box Int, Int, Int, Int, d), e, f) -> ((Float, a, Float, Float, b, c), (Int, Int, Box Int, Box Int, Int, Int, Int, d), e, f)`
ˡp̲lace	function	`(Any a, Any b, Any c, Num d, Any e, Any f, Any g, Any h, Any i, Num j) => (((Float, a, Float, Float, b, c), (Int, Int, Box Int, Box Int, Int, Int, Int, d), e, (f, g, h, i, j)), Int) -> (((Float, a, Float, Float, b, c), (Int, Int, Box Int, Box Int, Int, Int, Int, d), e, (f, g, h, i, j)), Int)`
ʰc̲hoose	function	`(Any a, Any b, Any c, Num d, Any e, Any f, Any g, Num h, Any i) => (Char, (a, b, c, (d, e, f, g, h)), Int) -> i -> ((a, b, c, (d, e, f, g, h)), Int)`
ʰn̲ightIf	function	`(Truthy a, Any b, Any c, Any d, Num e, Any f, Any g, Any h, Num i) => a -> (b, c, d, (e, f, g, h, i)) -> (b, c, d, (e, f, g, h, i))`
ʰi̲f	function	`(Truthy a, Any b, Any c, Any d, Any e, Any f, Any g, Any h) => a -> ((b, Float, Float, Float, Float, Float), c, d, (e, f, b, g, h)) -> ((b, Float, Float, Float, Float, Float), c, d, (e, f, b, g, h))`
ʰf̲ly	function	`(Truthy a, Any b, Any c, Any d, Any e, Any f, Any g) => a -> ((b, Float, c, d, Float, Float), e, f, g) -> ((b, Float, c, d, Float, Float), e, f, g)`
ʰw̲hen	function	`(Truthy a, Any b, Any c, Any d, Num e, Any f, Any g) => a -> ((Float, b, Float, Float, c, d), (Int, Int, Box Int, Box Int, Int, Int, Int, e), f, g) -> ((Float, b, Float, Float, c, d), (Int, Int, Box Int, Box Int, Int, Int, Int, e), f, g)`
ʰp̲laceIf	function	`(Truthy a, Any b, Any c, Any d, Num e, Any f, Any g, Any h, Any i, Any j, Num k) => a -> (((Float, b, Float, Float, c, d), (Int, Int, Box Int, Box Int, Int, Int, Int, e), f, (g, h, i, j, k)), Int) -> (((Float, b, Float, Float, c, d), (Int, Int, Box Int, Box Int, Int, Int, Int, e), f, (g, h, i, j, k)), Int)`
ˡf̲rame	function	`(Num a, Num b, Num c, Num d) => (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, a), (b, Int, Int, Int), (Int, Int, Float, c, d)), Int) -> (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, a), (b, Int, Int, Int), (Int, Int, Float, c, d)), Int)`
ˡf̲rameV	function	`(Num a, Num b, Num c, Num d) => (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, a), (b, Int, Int, Int), (Int, Int, Float, c, d)), Int) -> (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, a), (b, Int, Int, Int), (Int, Int, Float, c, d)), Int, Char)`
normals	value	`Int`
q	value	`Int`
cubies	value	`Int`
ʰm̲akeStickers	function	`Any a => a -> Int`
ˡstickers	value	`Int`
ˡsolved	value	`Int`
ʰk̲ey	function	`Num a => a -> a`
ʰr̲otate	function	`(Num a, Num b) => a -> b -> b`
ˡp̲ermutation	function	`Any a => Int -> a -> Int`
ˡnames	value	`Char`
specs	value	`Int`
ˡmoves	value	`Int`
ˡt̲urn	function	`Int -> a -> a`
ˡu̲ndo	function	`Int -> Int`
ʰs̲quaresAt	function	`Float -> Int -> Float`
ˡsquares	value	`Float`
shell	value	`Int`
bodyrows	value	`Int`
ˡbodies	value	`Float`
ˡc̲olorSquares	function	`Eq a => a -> a -> Float`
ˡrgb	value	`Float`
ˡs̲pec	function	`Int -> Int`
ˡr̲otation	function	`(Num a, Any b) => (a, Float) -> b -> Float`
ˡt̲urned	function	`Num a => a -> a -> a`
ʰc̲orners	function	`Truthy a => a -> Int`
ˡd̲raw	function	`(Num a, Num b) => (Int, Int, Float) -> a -> b`
ˡbw	value	`Float`
ˡbh	value	`Float`
ˡgap	value	`Float`
ˡw̲ords	function	`Char -> Box Char`
ˡl̲efts	function	`Any a => (Int, Float, Float) -> a -> Float`
ˡd̲rawRow	function	`Num a => (a, Char, Float, Float, Int, Float) -> Int -> Float`
ʰl̲abelHead	function	`Num a => (a, Int, Float, Float, Float, Int) -> Float`
ˡh̲it	function	`Any a => (Char, Int, Float, Float, Float) -> a -> Int`
ˡstart	value	`(Int, Int, Int, Int, Int)`
ˡq̲ueue	function	`(Any b, Any c, Any d, Any e) => a -> (b, c, a, d, e) -> (b, c, a, d, e)`
ˡa̲dvance	function	`Num a => (a, a) -> (Int, Int, Int, Int, a) -> (Int, Int, Int, Int, a)`
ʰs̲how	function	`Num a => (Int, Int, Int, Int, a) -> a -> (Int, Int, Int, Int, a)`
ˡu̲ndo	function	`(Any a, Num b, Any c) => (a, Int, Int, b, c) -> (a, Int, Int, b, c)`
ˡa̲pplied	function	`Int -> Int`
ʰa̲pply	function	`Num a => (Int, Int) -> a -> Int`
ˡi̲dle	function	`(Any a, Num b, Any c, Num d, Truthy d) => (a, Int, Int, b, c) -> d`
ˡn̲ames	function	`Int -> Char`
h	value	`Int`
b	value	`Int`
t	value	`Int`
p	value	`Char`
p	value	`Char`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
b	value	`Int`
ed	value	`Int`
e	value	`Int`
ᵘc̲ell	function	`Int -> a -> a`
hud	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
last	value	`(((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int)), Int)`
z	value	`Int`
ᵘw̲orldOf	function	`(Any a, Any b) => (a, b) -> a`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
ᵘf̲rame	function	`(Num a, Num b, Num c) => ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)) -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c))`
ᵘi̲f	function	`(Truthy a, Num b, Num c, Num d) => a -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d)) -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d))`
last	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
z	value	`Int`
ones	value	`Int`
inside	value	`Int`
one	value	`Int`
checker	value	`Bool`
b	value	`Int`
f	value	`Int`
w	value	`Int`
k	value	`Int`
ᵘp̲ut	function	`Int -> Int`
put	value	`Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`Num a => a -> a`
last	value	`Int`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
ᵘf̲rame	function	`(Num a, Num b, Num c) => ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)) -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c))`
ᵘi̲f	function	`(Truthy a, Num b, Num c, Num d) => a -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d)) -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d))`
ᵘf̲ly	function	`(Truthy a, Num b, Num c, Num d) => a -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d)) -> ((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (b, Int, Int, Int), (Int, Int, Float, c, d))`
last	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
z	value	`Int`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
x0	value	`Int`
ᵘt̲op	function	`Int -> Int`
ᵘm̲ore	function	`Int -> Int`
first	value	`Int`
gems	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
minutes	value	`Int`
total	value	`Int`
ᵘk̲ey	function	`Num a => a -> a`
ᵘc̲lock	function	`Int -> Char`
ᵘs̲how	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Num i, Any k, Any l) => (((Float, a, b, c, d, e), f, g, h), (i, j, Int, k, l)) -> (i, j, Int, k, l)`
ᵘn̲ear	function	`(Num a, Truthy a, Num b) => a -> (b, Float) -> Char`
ᵘe̲nd	function	`(Num c, Truthy c, Any d) => (a, b, Int, c, d) -> (a, b, Int, c, d)`
ᵘv̲erdict	function	`Truthy a => a -> (b, Int) -> Char`
ᵘf̲inds	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Any g, Any h, Any i, Any j, Any k, Num l, Truthy l, Any m, Any n) => ((a, (b, c, d, e, f, g, h, i), j, k), (f, l, m, n, Int)) -> (f, l, m, n, Int)`
ᵘt̲ell	function	`(Num a, Truthy a, Num b, Num c, Truthy c) => a -> (b, c) -> Char`
ᵘf̲rame	function	`(Num a, Num b, Num c, Num d, Truthy d, Num e, Truthy e) => (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)), Int, (Int, d, Int, e, Int)) -> (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)), Int, (Int, d, Int, e, Int))`
ᵘt̲urn	function	`(Num a, Num b, Num c, Num d, Truthy d, Num e, Truthy e) => (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)), Char, (Int, d, Int, e, Int)) -> (Int, d, Int, e, Int)`
hud	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
game	value	`(Int, Int, Int, Int, Int)`
last	value	`(((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int)), Int, (Int, Int, Int, Int, Int))`
z	value	`Int`
ᵘg̲ameOf	function	`(Any a, Any b, Any c) => (a, b, c) -> c`
ᵘf̲oundOf	function	`(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> b`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
cell	value	`Int`
x	value	`Int`
y	value	`Int`
z	value	`Int`
shaft	value	`Int`
tunnel	value	`Int`
lamp	value	`Int`
b	value	`Int`
ᵘs̲unOf	function	`(Any a, Any b) => (a, b) -> a`
ᵘl̲ampOf	function	`(Any a, Any b) => (a, b) -> b`
L	value	`(Int, Int)`
row	value	`Int`
hud	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
last	value	`(((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int)), Int)`
z	value	`Int`
ᵘw̲orldOf	function	`(Any a, Any b) => (a, b) -> a`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
w	value	`Int`
k	value	`Int`
z	value	`Int`
names	value	`Char`
turns	value	`Int`
keys	value	`Char`
top	value	`Float`
o	value	`Int`
ᵘl̲ight	function	`(Any a, Any b, Any c, Any d, Any e) => (a, b, c, Int, d) -> e -> (a, b, c, Int, d)`
ᵘl̲ightIf	function	`(Truthy a, Any b, Any c, Any d, Any e) => a -> (b, c, d, Int, e) -> (b, c, d, Int, e)`
ᵘu̲nder	function	`(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> d`
title	value	`Int`
ᵘs̲ay	function	`(Any a, Any b, Any c, Any d, Any e) => (a, Int, b, c, d) -> e -> (a, Int, b, c, d)`
ᵘp̲ressed	function	`Char -> Int`
ᵘp̲ush	function	`(Num a, Any b, Any c, Any d, Any e) => a -> (b, c, a, d, e) -> (b, c, a, d, e)`
ᵘu̲ndoIf	function	`(Truthy a, Any b, Num c, Any d) => a -> (b, Int, Int, c, d) -> (b, Int, Int, c, d)`
ᵘs̲ayIf	function	`(Truthy a, Any b, Any c, Any d, Any e) => a -> (b, Int, c, d, e) -> (b, Int, c, d, e)`
ᵘm̲ade	function	`(Any a, Any c, Any d, Any e) => (a, b, c, d, e) -> Int`
ᵘf̲rame	function	`Num a => ((Int, Int, Int, Int, Int), a) -> ((Int, Int, Int, Int, Int), a)`
ᵘr̲edraw	function	`(Num a, Num b) => ((Int, Int, Int, Int, Int), a) -> b -> ((Int, Int, Int, Int, Int), a)`
last	value	`((Int, Int, Int, Int, Int), Int)`
z	value	`Int`
ᵘc̲olorsOf	function	`(Any a, Any b, Any c, Any d, Any e, Any f) => ((a, b, c, d, e), f) -> a`
ᵘt̲urnsOf	function	`(Any a, Any b, Any c, Any d, Any e, Any f) => ((a, b, c, d, e), f) -> b`
c	value	`Int`
h	value	`Int`
w	value	`Int`
k	value	`Int`
z	value	`Int`
map	value	`Int`
names	value	`Char`
turns	value	`Int`
keys	value	`Char`
top	value	`Float`
controls	value	`Char`
top2	value	`Float`
cw	value	`Float`
ᵘb̲uttons	function	`Int -> Int`
o	value	`Int`
title	value	`Int`
ᵘt̲ell	function	`Char -> Char`
ᵘs̲ay	function	`(Any a, Any b, Any c, Any d, Any e) => (a, Int, b, c, d) -> e -> (a, Int, b, c, d)`
ᵘs̲crambled	function	`Num a => a -> Int`
ᵘm̲ore	function	`(Num a, Num b) => (a, Int) -> b -> (a, Int)`
ᵘs̲olution	function	`(Any a, Any b, Any c, Any d) => (a, Int, b, c, d) -> Int`
ᵘp̲ressed	function	`Char -> Int`
ᵘt̲urnBy	function	`(Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Num j, Num k, Num l) => a -> ((b, c, a, d, e), f, g, h, i) -> ((b, c, a, d, e), j, k, l, i)`
ᵘc̲ontrol	function	`(Num a, Num b, Any c, Num d, Any e) => a -> ((Int, Int, Int, b, c), Int, Int, d, e) -> ((Int, Int, Int, b, c), Int, Int, d, e)`
ᵘs̲cramble	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘs̲olveSoon	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘs̲ayIt	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> Char -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘb̲ack	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘs̲tep	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘp̲lay	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘs̲olveNow	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Num i, Num j) => ((a, Int, b, c, d), e, f, g, h) -> ((a, Int, b, c, d), Int, i, j, h)`
ᵘp̲layOn	function	`(Num a, Any b, Num c, Any d) => ((Int, Int, Int, a, b), Int, Int, c, d) -> ((Int, Int, Int, a, b), Int, Int, c, d)`
ᵘr̲eset	function	`(Any a, Any b, Any c, Any d, Any e, Num f, Num g, Num h) => (a, b, c, d, e) -> ((Int, Int, Int, Int, Int), f, g, h, e)`
ᵘm̲ade	function	`(Any a, Any c, Any d, Any e) => (a, b, c, d, e) -> Int`
ᵘu̲nder	function	`(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> d`
ᵘs̲ayIf	function	`(Truthy a, Any b, Any c, Any d, Any e) => a -> (b, Int, c, d, e) -> (b, Int, c, d, e)`
ᵘf̲rame	function	`(Num a, Num b) => ((Int, Int, Int, Int, Int), Int, Int, a, b) -> ((Int, Int, Int, Int, Int), Int, Int, a, b)`
ᵘs̲olveIf	function	`(Truthy a, Num b, Num c) => a -> ((Int, Int, Int, Int, Int), Int, Int, b, c) -> ((Int, Int, Int, Int, Int), Int, Int, b, c)`
ᵘa̲ct	function	`(Num a, Num b, Num c) => (Int, ((Int, Int, Int, Int, Int), Int, Int, a, b)) -> c -> ((Int, Int, Int, Int, Int), Int, Int, a, b)`
ᵘl̲ightIf	function	`Truthy a => a -> Int -> Int`
last	value	`((Int, Int, Int, Int, Int), Int, Int, Int, Int)`
z	value	`Int`
ᵘc̲olorsOf	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i) => ((a, b, c, d, e), f, g, h, i) -> a`
ᵘt̲urnsOf	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i) => ((a, b, c, d, e), f, g, h, i) -> b`
ᵘm̲adeOf	function	`(Any a, Any b, Any c, Any d, Any e) => (a, b, c, d, e) -> c`
c	value	`Int`
h	value	`Int`
pos	value	`Int`
pts	value	`Int`
C	value	`Int`
kind	value	`Int`
z	value	`Int`
I	value	`Int`
ˡsolved	value	`Int`
N	value	`Int`
ˡfaces	value	`Char`
V	value	`Int`
dir	value	`Int`
E	value	`Int`
Mf	value	`Int`
M	value	`Int`
ʰt̲urns	function	`Int -> Int`
ʰp̲os	function	`Int -> Int`
ʰc̲hildren	function	`Int -> Int`
ˡt̲urn	function	`Int -> Int -> Int`
ˡd̲o	function	`Int -> Int -> Int`
across	value	`Int`
down	value	`Int`
ˡs̲tickers	function	`Int -> Int`
ʰg̲row	function	`Int -> Int`
G	value	`Int`
Tm	value	`Int`
ʰo̲rient	function	`Int -> Int`
at	value	`Int`
layer	value	`Int`
ʰn̲ext	function	`Int -> Int`
ʰr̲elax	function	`Num a => a -> a`
ʰd̲istances	function	`Num a => a -> a`
colDev	value	`Int`
Dsolved	value	`Int`
ˡs̲olved?	function	`Truthy a => Int -> a`
posDev	value	`Int`
Dplace	value	`Int`
yellowDown	value	`Int`
sets	value	`Int`
ʰs̲pec	function	`Num a => a -> a`
ʰo̲f	function	`Int -> Int -> Int`
ʰr̲elevant	function	`Truthy a => Int -> a`
ʰp̲roject	function	`Num a => a -> a -> a`
ʰs̲core	function	`Int -> Int -> Float`
batch	value	`Int`
greed	value	`Float`
ˡi̲nverse	function	`Int -> Int`
ʰf̲ace	function	`Int -> Int`
ʰc̲ubes	function	`Int -> Int`
ʰk̲ey	function	`Num a => a -> a`
macros	value	`Box Int`
middle	value	`Int`
bottom	value	`Int`
ʰa̲ctions	function	`(Num a, Num b) => a -> b -> Int`
ʰa̲long	function	`Int -> Int -> Int`
ʰm̲acros	function	`Int -> Int -> Int`
ʰe̲xpand	function	`Int -> Int -> Int`
ʰf̲latten	function	`Int -> Int`
ʰs̲tep	function	`Num a => (Int, Int) -> (Int, Int, Int, Int, a, Float, Int) -> Int`
ʰt̲race	function	`(Int, Int) -> Int -> Int`
ʰs̲earch	function	`(Int, Int) -> Int -> Int`
ʰs̲tage	function	`Num a => a -> (Int, Int, Int) -> (Int, Int, Int)`
twist	value	`Int`
bottomTurn	value	`Int`
ʰo̲riented?	function	`Int -> Int`
ʰc̲orner	function	`(Int, Int) -> (Int, Int)`
ʰf̲inish	function	`(Int, Int) -> (Int, Int)`
ˡs̲olve	function	`Num a => a -> Int -> (Int, Int, Int)`
ˡn̲ame	function	`Int -> Char`
ˡp̲arse	function	`Char -> Int`
w	value	`Int`
k	value	`Int`
scramble	value	`Int`
turns	value	`Int`
frames	value	`Int`
rest	value	`Int`
pause	value	`Int`
names	value	`Box Char`
ᵘp̲aint	function	`(Any a, Num b) => (Int, Int, Int) -> a -> b`
ᵘa̲fter	function	`(Int, Int) -> a -> a`
ᵘa̲nnounce	function	`(Num a, Num b) => a -> Int -> b`
ᵘs̲ay	function	`(Num a, Truthy a, Num b) => a -> Char -> b`
ᵘs̲how	function	`Any a => (Int, Int, Int, a) -> (Int, Int, Int, a)`
ᵘf̲rame	function	`Num a => (Int, Int, Int, a) -> (Int, Int, Int, a)`
ᵘq̲uit	function	`Num a => (Int, Int, Int, a) -> (Int, Int, Int, a)`
shown	value	`Int`
last	value	`(Int, Int, Int, Int)`
s	value	`Int`
ᵘf̲our	function	`Truthy a => Int -> a`
ᵘb̲ack	function	`Truthy a => Int -> a`
ᵘs̲exy	function	`a -> a`
ᵘs̲exyN	function	`Truthy a => Int -> a`
ᵘr̲u	function	`a -> a`
ᵘr̲uN	function	`Truthy a => Int -> a`
m	value	`Int`
top	value	`Int`
w	value	`Int`
k	value	`Int`
b	value	`Int`
ᵘd̲raw	function	`Int -> Int`
shown	value	`Int`
letters	value	`Char`
ᵘt̲ell	function	`(Any a, Any b) => a -> b -> b`
ᵘs̲ay	function	`Any a => (Int, Int, a) -> (Int, Int, a)`
ᵘt̲urnBy	function	`Any a => Int -> (Int, Int, a) -> (Int, Int, a)`
ᵘu̲ndoLast	function	`Any a => (Int, Int, a) -> (Int, Int, a)`
ᵘo̲ne	function	`Any b => (a, Int, b) -> (a, Int, b)`
ᵘs̲cramble	function	`Any a => (Int, Int, a) -> (Int, Int, a)`
ᵘr̲eset	function	`(Any a, Any b, Any c, Num d) => (a, b, c) -> (Int, d, c)`
ᵘq̲uit	function	`(Any a, Any b, Any c, Num d) => (a, b, c) -> (a, b, d)`
ᵘf̲rame	function	`Num a => (Int, Int, a) -> (Int, Int, a)`
last	value	`(Int, Int, Int)`
b	value	`Int`
f	value	`Int`
w	value	`Int`
k	value	`Int`
g	value	`Int`
ᵘp̲ut	function	`Int -> Int`
put	value	`Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`Num a => a -> a`
last	value	`Int`
h	value	`Int`
b	value	`Int`
ts	value	`Int`
b	value	`Int`
f	value	`Int`
sv	value	`Int`
w	value	`Int`
g	value	`Int`
c	value	`Int`
keys	value	`Int`
ᵘp̲ut	function	`Int -> Int`
put	value	`Int`
dt	value	`Float`
ᵘs̲et	function	`Float -> Float -> Float`
ᵘh̲it	function	`Float -> Float`
ᵘs̲nap	function	`Float -> Float -> Float`
ᵘm̲x	function	`Float -> Float`
ᵘm̲z	function	`Float -> Float`
ᵘm̲y	function	`Float -> Float`
ᵘs̲tep	function	`Float -> Float`
ᵘi̲nView	function	`Truthy a => Float -> a`
ᵘc̲hunks	function	`Float -> Float`
j	value	`Int`
inner	value	`Int`
hv	value	`Int`
i	value	`Int`
sx	value	`Float`
sz	value	`Float`
yaw0	value	`Float`
start	value	`Float`
s	value	`Float`
e	value	`Int`
ᵘq̲uit	function	`Any a => a -> Float`
ᵘf̲rame	function	`Float -> Float`
last	value	`Float`
w	value	`Int`
g	value	`Int`
k	value	`Int`
k	value	`Int`
hv	value	`Int`
cell	value	`Int`
cx	value	`Int`
cy	value	`Int`
cz	value	`Int`
gt	value	`Int`
T	value	`Int`
r	value	`Int`
top	value	`Int`
pool	value	`Int`
fill	value	`Int`
blk	value	`Int`
ᵘc̲ells	function	`Int -> Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
lake	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
ᵘm̲easure	function	`(Any a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j) => (a, (b, c, d, e, f, g, Int, h), i, j) -> (a, (b, c, d, e, f, g, Int, h), i, j)`
ᵘm̲easureIf	function	`(Truthy a, Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => a -> ((b, (c, d, e, f, g, h, Int, i), j, k), l) -> (b, (c, d, e, f, g, h, Int, i), j, k)`
ᵘm̲easureAt	function	`(Any b, Any c, Any d, Any e, Any f, Any g, Any h, Any i, Any j, Any k) => a -> (b, (c, d, e, f, g, h, Int, i), j, k) -> (b, (c, d, e, f, g, h, Int, i), j, k)`
ᵘf̲rame	function	`(Num a, Num b, Num c, Num d, Truthy d, Num e) => (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)), Int, d, e) -> (((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (a, Int, Int, Int), (Int, Int, Float, b, c)), Int, d, e)`
hud	value	`Int`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
last	value	`(((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int)), Int, Int, Int)`
z	value	`Int`
ᵘw̲orldOf	function	`(Any a, Any b, Any c, Any d) => (a, b, c, d) -> a`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
s	value	`((Float, Float, Float, Float, Float, Float), (Int, Int, Box Int, Box Int, Int, Int, Int, Int), (Int, Int, Int, Int), (Int, Int, Float, Int, Int))`
h	value	`Int`
b	value	`Int`
ts	value	`Int`
b	value	`Int`
f	value	`Int`
c	value	`Int`
w	value	`Int`
k	value	`Int`
g	value	`Int`
keys	value	`Int`
ᵘp̲ut	function	`Int -> Int`
put	value	`Int`
ᵘq̲uit	function	`(Any a, Num b) => a -> b`
ᵘf̲rame	function	`Num a => a -> a`
last	value	`Int`
db	value	`Char`
x	value	`Int`
n	value	`Int`
m	value	`Float`
y	value	`Float`
c	value	`Float`
ᵘr̲ound	function	`Float -> Float`
d	value	`Float`
yb	value	`Float`
cb	value	`Float`
s	value	`Float`
e	value	`Float`
k	value	`Int`
b	value	`Int`
h	value	`Int`
p	value	`Char`
w	value	`Float`
v	value	`Float`
p	value	`Char`
ˡs̲erve!	function	`Num a => a -> Int`
ˡn̲ext!	function	`Num a => a -> Char`
ˡm̲ethod	function	`Unit -> Char`
ˡp̲ath	function	`Unit -> Char`
ˡq̲uery	function	`Unit -> Char`
ˡb̲ody	function	`Unit -> Char`
ˡp̲aram	function	`Char -> Char`
ˡc̲ontent!	function	`Char -> Int`
ˡh̲eader!	function	`Char -> Int`
ˡr̲eply!	function	`Num a => a -> Char -> Int`
ˡf̲iles!	function	`Char -> Int`
ˡs̲top!	function	`Unit -> Int`
ˡpackage	value	`Char`
ᵘl̲ife	function	`(Num a, Truthy a) => a -> a`
ᵘs̲eed	function	`Truthy a => Int -> a`
ᵘg̲lider	function	`Num a => Int -> a`
ᵘs̲ize	function	`Char -> Int`
ᵘj̲oin	function	`Box Char -> Char`
ᵘs̲vg	function	`Truthy a => a -> Char`
page	value	`Char`
ᵘa̲nswer	function	`(Num a, Truthy a) => a -> a`
port	value	`Int`
last	value	`Int`
port	value	`Int`
db	value	`Char`
made	value	`Int`
items	value	`Char`
ᵘf̲ilter	function	`Char -> Char`
ᵘl̲eft	function	`Num a => a -> Char`
ᵘo̲n	function	`Char -> Char -> Char`
ᵘl̲ink	function	`Char -> Char -> Char`
ᵘl̲inks	function	`Char -> Char`
style	value	`Char`
ᵘp̲age	function	`Char -> Char`
ᵘb̲ack	function	`Any a => a -> Int`
ᵘa̲dd	function	`Char -> Int`
ᵘa̲nswer	function	`Num a => a -> a`
port	value	`Int`
last	value	`Int`
port	value	`Int`