a

68 files changed, 10132 insertions, 0 deletions

diff --git a/docs/history/13-gap-fixes/code/README.md b/docs/history/13-gap-fixes/code/README.md
new file mode 100644
index 0000000..ce56f28
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/README.md
@@ -0,0 +1,422 @@
+# tinyvm zygote: notes and transcript
+
+a tiny stack cpu that started as a c89 code golf entry and ended up as a self-hosting runtime. a small native core runs vm code: jit-compiled to arm64, compiled through llvm on other hosts if you build with it, or interpreted. the genome it boots is a compiler for zc, a c-like language that keeps the forth habits. the compiler lives in vm memory next to your program, and your program can call into it, patch its tables, add syntax to it and compile new code while it runs. heap objects carry an ownership tag (u, m or d) that a static analyzer inside the compiler checks, with deterministic frees at scope ends and a mark-sweep collector underneath. types are a compiler primitive, with structs, generics, reflection and an optional typechecker. a program can also wire up to 512 custom opcodes into the cpu (virtual enhancements), which the jits inline as native code.
+
+this folder has the latest code. `history/` is the scrapbook: notes for every stage, plus frozen code from the stages that still have it.
+
+## files
+
+`core.c` is the native core and the only native code at runtime: the arm64 jit, the llvm backend (behind `-DZYLLVM`), the portable interpreter, and the enhancement unit (recipe parser, vm-code lifter, optimizer and lowering). `src/rt.zc` is the runtime (i/o, the native division enhancements, the heap and the collector) and `src/compiler.zc` is the compiler, both written in zc. together they are the genome. `zc0.c` is stage 0 of the bootstrap, a compiler in c for the subset of zc that `compiler.zc` is written in. `tools/build.zc` makes the resident compiler compile its own source into a fresh image, and `mkgenome.c` turns that image into `genome.h`, which is generated and checked in. `examples/` has hello, factorial, echo, self-patching code, an owning list, a repl, a typed program and an enhancement demo. `tests/` has feature tests, `tests/errors/` (programs the lifetime analyzer has to reject) and `tests/typeerrors/` (programs the typechecker has to reject). each of those starts with the message it expects, and `tests/runerr.sh` runs a folder of them. `test.sh` does the whole bootstrap and runs everything on all three backends. `history/` is the scrapbook.
+
+## build
+
+```
+cc -O2 core.c io_linux.c -o zy                       # io_linux.c provides Q, G and J
+./zy <examples/hello.zc
+cc -O2 -DZYLLVM $(llvm-config --cflags) core.c io_linux.c -o zy $(llvm-config --ldflags --libs)
+```
+
+on arm64 the first line builds the jit, anywhere else the interpreter. the second line builds the llvm backend (non-arm64, or arm64 with `-DZYINTERP`). `-DZYINTERP` forces the plain interpreter. `J` is a `char` by default, so compile with `-DJTYPE=int` if yours is an int. the source ends at eof or at a backtick, and anything after the backtick stays unread for the program itself. environment: `ZYTRACE=1` logs translations, installs and the optimized enhancement code on stderr, and on the llvm build `ZYHOT=n` sets how many runs a block needs before it gets compiled (default 5000) and `ZYPASSES` the llvm pass pipeline (default `default<O2>`). `ZYNOLLVM=1` turns the llvm tier off.
+
+regenerating the genome after changing `src/`:
+
+```
+cc zc0.c -o zc0 && cc mkgenome.c -o mkgenome
+cat src/rt.zc src/compiler.zc | ./zc0 >genome.h            # stage 0, from c
+cc -O2 core.c io_linux.c -o zy
+(cat tools/build.zc; printf '`'; cat src/rt.zc src/compiler.zc) | ./zy | ./mkgenome >g.h
+mv g.h genome.h && cc -O2 core.c io_linux.c -o zy           # now built by itself
+```
+
+run the last two lines once more and `genome.h` should come out byte for byte the same. `test.sh` checks that, on every backend.
+
+## zc, the language
+
+it reads like c. underneath every value is a 32 bit word and memory is word addressed, so `p + 1` is the next word whatever `p` points at, and strings are one char per word with a 0 at the end. types are optional: untyped code is typed `word`, which goes with anything.
+
+```
+const N = 10;
+[N]int table;                              // a global array
+fn fib(int n) -> int { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
+fn main() {
+	for (int i = 0; i < N; i++) table[i] = fib(i);
+	let sq = { let t = table[5]; t * t };     // a block is an expression too, its last line is its value
+	let x = asm { 2 3 + };                    // raw vm code, leaves one value
+	putn(sq + x); putc(10);
+	return 0;
+}
+```
+
+declarations are c-style, type first: `int a = 1, b;`, `*node p = new(node);`, `[4]char buf;`, `point origin;`. `let` declares without a type: it infers pointer, struct and function types from the initializer and keeps numbers as plain words, and `let a[10];` is an untyped array. statements are declarations, `if`/`else`, `while`, `for`, `switch`, `break`, `continue`, `return`, `{ }` blocks, `asm { }` and expressions. `switch (e) { case 1, 2: ... default: ... }` takes constant labels, and its cases don't fall through: each ends where the next begins, and `break` leaves early. operators are c's with c's precedence, including `c ? a : b`, plus `p.x` and `p->x` (the same thing: `.` goes through a pointer on its own), `e as T` to change a type without changing the bits, and the casts below. comparisons and `&& ||` give 0 or 1. `/`, `%` and `<<` compile to native enhancement opcodes. character literals, `0x` hex and the usual escapes are there.
+
+a unit is read whole and scanned for function signatures before it compiles, so calls can come before definitions, tags included, and prototypes are optional. `main` runs after the whole program has compiled. every function returns one word, 0 if it falls off the end.
+
+builtins from the runtime: `putc`, `getc`, `eof`, `puts`, `putn`, `halt`, `strlen`, `streq`, `wcopy`, `wfill`, `new`, `new_t`, `free`, `gc`, `isobj`, `osize`, `typeof_obj`, `live_objects`, `install`, `zdiv`, `zmod`, `zshl`.
+
+## memory model: u, m and d
+
+`new(n)` or `new(T)` gives back a fresh object. bind it to a local and the local owns it, tagged **m**. tags live on local variables and parameters, the analyzer follows them through the code, and the compiler inserts `free` calls where owned objects die. a tag is written after the type, `*node.u p`, or alone, `.d x`. `u`, `m` and `d` are reserved words.
+
+**m** means the object belongs to this block and has to be used in it. you can lend it to callees as often as you like, and when the block ends it's freed. an m object that's never used anywhere in its block is an error.
+
+**d** means the object is going down. the first time it's handed to a lower scope its life here is over: passing it to a `.d` parameter, or touching it inside an inner block, which then owns it as m and frees it when that block ends. using it afterwards is an error, and so is ending the block with a d object that never left.
+
+**u** means the object is going up. it has to leave this block for the one above, where it arrives as m. it leaves through `return` (the function's return type has to carry `.u`, like `-> *node.u` or just `-> .u`), as the value of a block expression, or by assignment to a variable of the directly enclosing block. letting it fall out of scope, or throwing away a u result, is an error.
+
+recasting is multiplication by the tag: `u*x`, `d*x`, `m*x`. it only goes away from m: m can become u or d (and u and d can swap), but nothing goes back to m in the same scope. a declaration can carry a tag too, `.u r;`, and then whatever lands in it gets that tag.
+
+parameters: an untagged parameter is m from the caller's side, a lend, and the callee sees a plain word. `.m` makes it a checked borrow: the callee can read and write it but can't free it, return it, recast it or store it anywhere. `.d` hands the object over, and it arrives as m.
+
+```
+fn box(int v) -> *int.u { *int b = new(int); *b = v; return u*b; }
+fn push(*list l, *int.d item) { l.items[l.len] = d*item; l.len++; return 0; }
+```
+
+containers own what you store in them. `p[i] = c` or `p.f = c` needs `c` to carry the same tag as `p` (or be a fresh object), and from then on `c` follows `p`: if `p` is recast, so is `c`, if `p` is given away `c` goes with it, and when `p` is freed its children are freed too. a child can't be recast or given away on its own. storing into an object you only borrowed gives the child away: it's dead here afterwards, and the caller's object owns it. the runtime records the owner in the child's header, so freeing a container frees exactly the objects it owns.
+
+globals, plain pointers and arrays aren't tracked. storing an owned object there needs `d*`, and the mark-sweep collector takes it over. a fresh object can go straight in.
+
+where paths join (after an `if`, a loop, a `switch` or `?:`) every variable has to be in the same state on every path that reaches the join, with one exception. a variable that became d, or was given away, on some path is dead afterwards, and the compiler frees it on the paths where it's still alive, on their way in. a loop's exit state is the join of its `break`s and its normal exit, so giving something away and breaking is fine. what a loop can't do is give something away on a path that comes back around to the top, since the next pass would use it dead. a u object doesn't get the dead treatment: it still has to leave.
+
+### the analyzer
+
+it runs inside the compiler on every function, including code compiled at runtime by `eval` and friends, and reports each violation with a line number and the variable's name. the compiler keeps going after errors, up to 20: a syntax error skips to the next `;` or `}` (or the next top-level declaration), and analyzer and type errors just get reported, since the parse is still in step. a unit with errors doesn't run. `tests/errors/` has one small program per rule. to turn it off: `unchecked fn f() { }` for one function, `unchecked { }` for a block, and a top-level `unchecked;` for the rest of the unit (a parse word can also set `check_on = 0`). unchecked code doesn't track anything, so what it allocates belongs to the collector, and checked variables can't be touched from inside an unchecked block.
+
+## types
+
+types are a compiler primitive. the compiler keeps them as records in a type area at 0x9C000, hash-consed so the same type is always the same pointer. they stay in memory after compiling, so programs and parse words can look at them.
+
+```
+struct point { int x, y; };
+struct list<T> { int len; *T items; };
+type num = int;
+fn first<T>(*list<T> l) -> T { return l.items[0]; }
+fn mk<T>(int cap) -> *list<T>.u { *list<T> l = new(list<T>); l.items = new(T, cap); return u*l; }
+...
+*list<*point> ps = mk<*point>(8);       // explicit type arguments, or inferred from the arguments
+```
+
+the kinds are `word`, `int`, `char`, `bool`, `void`, pointers `*T`, fixed arrays `[n]T`, function types `fn(int, *char) -> int`, structs, generic structs and generic functions. structs and arrays live in place (in a frame, a global or inside another struct), and their value is their address, so they're passed around by pointer. `sizeof` counts words. type arguments have to be one word (a number, a pointer or another parameter), so a generic function is compiled once and works for every instance. indexing scales by the element's size, while plain pointer arithmetic stays in words, like b. `new(T)` and `new(T, n)` stamp the type into the object's header.
+
+### reflection
+
+`typeof(e)` and `typeof(T)` give a type record and `sizeof(...)` its size. both work on any expression, which is compiled dry and never runs. at runtime: `tkind(t)` (one of the `TY_` constants), `tsize`, `tname`, `tlen`, `tnfields`, `tfname(t, i)`, `tftype`, `tfoff`, `tret`, `tnparams`, `tparam`, `tparamtag` (the u/m/d tag of a parameter), `tretu`, `tnargs` and `targ` for generic instances, and `tprint(t)`. `sigof(f)` gives the type of a function by address (untyped ones get a signature built from their arity and tags), `sigofs("name")` by name, and `typeof_obj(p)` reads the type stamped on a heap object.
+
+### the typechecker
+
+off by default. `typecheck on;` turns it on for what follows and `typecheck off;` turns it back off (a parse word can flip `tc_on`). it checks initializers, assignments, arguments (unifying generic parameters), return values, arithmetic, comparisons, dereferencing, indexing and calls. `word` matches anything, numbers mix with each other, a literal 0 is a null pointer, and arrays decay to pointers. it stops at the first error, printing what it expected and what it got. `tests/typeerrors/` has one per rule. some things are checked whatever the setting, because the compiler needs them to generate code: field names, and field access on something that isn't a struct.
+
+## virtual enhancements
+
+the cpu has room for 512 custom opcodes (22 to 533), and opcode 21 (`%` in asm) installs one at runtime. it's the closest a soft cpu gets to rewiring itself. an enhancement takes up to 8 inputs off the data stack and leaves up to 8 outputs, and it's written one of two ways:
+
+```
+enhance clamp(x, lo, hi) micro "x = max x lo; x = min x hi";
+enhance divmod(a, b) -> 2 micro "r2 = sdiv a b; r1 = srem a b; r0 = r2";
+enhance cube(x) vm { 0 $ 0 $ * * };
+enhance noisy(x) vm { 0 $ . } else soft_noisy;    // can't be lifted (it does i/o), so calls use the fallback
+```
+
+a micro recipe works on registers `r0`..`r15`, which the inputs arrive in (also under the parameter names), and the outputs leave from `r0` up. the micro-ops are `li mov add sub mul sdiv udiv srem urem and or xor shl shr sar neg not lt ltu eq ne min max minu maxu mulhs mulhu clz abs sel ld st`. a `vm` body is straight-line vm code that gets lifted by running it symbolically. both turn into ssa, and the core's optimizer folds constants, simplifies algebra, removes common subexpressions and dead code, and turns division by a constant into a multiply-high sequence (`ZYTRACE=1` prints the result). the arm64 jit then inlines the code at every use with registers allocated, the llvm backend inlines it as ir, and the interpreter runs the optimized list. if something doesn't fit in registers, the jit calls the interpreter for that op.
+
+an enhancement is called like a function when it has one output, or by name from asm. `enhance` installs at compile time, so the wiring is there before `main` runs, and a parse word can use it right away. an image installs its own enhancements when it boots, from its symbol table. that's how `/`, `%` and `<<` work: `rt.zc` declares `idiv`, `imod` and `ishl` as one-instruction recipes. `install(desc)` is the raw interface, and its descriptor format is documented in `core.c`. stores done by an enhancement don't invalidate compiled code, so use them for data.
+
+this replaces my first plan for enhancements, which compiled c or llvm ir sources at runtime. part of that reply got stopped by a safety check, and once it turned out llvm was meant for portability, it moved into the backend below instead.
+
+## the llvm backend
+
+a tiered jit for hosts the arm64 backend doesn't cover. the interpreter counts how often each block start gets reached, and a hot block is translated to llvm ir using the same block rules as the arm64 jit: it ends at call, jump, ret or halt, keeps going past a jz, and literal targets are fused. the ir goes through the O2 pipeline and gets compiled by orc's lljit. stores into compiled words drop the blocks covering them, like on arm64. it pays off for long-running code: a loop-and-recursion benchmark runs about 3.3x faster than the interpreter. short bursty work like the self-compile is slower, since compile time dominates there. `ZYHOT=1` compiles every block, which is a good stress test, and the test suite runs that way too.
+
+## the heap
+
+0x40000 to 0x9BFFF, managed by a buddy allocator. the heap is split into aligned power-of-two chunks, every block is a power of two words, and a freed block merges with its buddy whenever that one is free too, so freed space can be reused at any size. allocation finds the smallest free block that fits and splits it down. free blocks sit on a doubly linked list per class, so taking a buddy off its list during a merge is constant time. checked code frees deterministically. under that runs a mark-sweep collector, conservative and non-moving, which handles globals, unchecked code and anything given to it. it runs on `gc()`, which returns how many objects it freed, or when an allocation doesn't fit. the sweep frees through the same merging path.
+
+## code as data
+
+the compiler is in memory with your program and every name in it is callable.
+
+`asm { }` emits raw vm words: numbers push, `-5` pushes a negative, `#n` emits a raw word, one-char tokens from the mnemonic table are opcodes, `:name` defines a label local to the block, enhancement names emit their opcode, and other names push the address of a variable or function.
+
+`quote { ... }` is a token list as a fresh object: `[n, kind, value, line, kind, value, line, ...]`, so errors inside a macro expansion point at the line the tokens came from, where names, strings and operators are interned pointers (`intern("while")` gets one). `tokens(s)` makes one from a string, and `qdup(q)` copies one.
+
+`eval(q)` compiles a token list as a function body and runs it. `compile(q)` returns its address instead, `load(q)` compiles top-level declarations, and `evals(s)` runs `eval` on a string.
+
+parse words: `immediate fn name() { }` runs at compile time whenever `name` shows up as a statement, inside an expression or at the top level. it starts with the current token on its own name and works the compiler directly: `next()`, `peek()` and `peekat(k)` (up to 4 tokens ahead), `tk`/`tv` (current token kind and value), `expect`, `accept`, `expr()`, `stmt()`, `substmt()`, `ptype()`, `emit`, `lit`, `op`, `hole`/`setlit` for jumps, and `here`. `grab()` reads a `{ }` group into a token list, and `feed(q)` pushes a list back into the input, which is all a macro needs. parse words can call `eval` partway through a compile: the compiler saves its state and emits the new function in place with a jump around it. the built-in keywords are entries in the same table, so a parse word called `while` replaces `while`.
+
+tables: `add_binop("**", 11, "ipow c")` adds or replaces a binary operator with a precedence and its code, written like asm (names resolve when it's used). `add_unop` does the same for prefix operators, and the lexer learns new spellings from both. `mnem` is the asm mnemonic table, `q@!$_~cjzr,?.+-*&|^><%`, and can be rewritten.
+
+## the bootstrap
+
+`zc0.c` compiles the subset `compiler.zc` uses (no analyzer, types, quote, parse words or block expressions, but it does lay out `enhance` declarations) into a first genome. that genome compiles `compiler.zc` again on the vm. that's where the real compiler, the analyzer and native division first meet their own source, and `compiler.zc` passes its own lifetime checks. the result compiles itself into identical words, on all three backends, and that's the `genome.h` that ships (71014 words). an image build (`build_image(org, dst)`) compiles with only the image's own names visible (plus keywords and builtin types), writes code meant for one address into another, and appends a symbol table so the booted genome knows its own names and enhancements.
+
+## the instruction set
+
+every word is 32 bits. an odd word is a literal that pushes `w>>1` (31 bits, sign extended). an even word is an opcode, `w/2`. there's a data stack and a return stack, both stored inside memory.
+
+```
+0 q halt    5 ~ swap    10 , in (Q)     15 * mul    20 < less
+1 @ load    6 c call    11 ? empty (J)  16 & and    21 % install
+2 ! store   7 j jump    12 . out (G)    17 | or     22..533 enhancements
+3 $ pick    8 z jz      13 + add        18 ^ xor
+4 _ drop    9 r ret     14 - sub        19 > shr
+```
+
+stack effects: `!` is `(v addr --)`, `$` is `(n -- copy of the nth item)` so `0 $` is dup, `z` is `(cond addr --)` and jumps when cond is 0, `c` and `j` take their target from the stack, and `%` is `(descriptor -- status)`. there's still no div or mod in the base set, because a divider can't finish in one cycle in hardware. an enhancement can add one.
+
+## memory map and abi
+
+memory is 1m (1048576) words. it could grow until the host runs out (literals already reach 1g words), but that would mean reserving the jit tables with mmap instead of static arrays, and 1m is plenty for now.
+
+```
+0x00000..        the program: code, with globals between functions
+0x40000..0x9BFFF heap
+0x9C000..0x9FFFF type records
+0xA0000          frame pointer word
+0xA0100..0xBFFFF compiler data: interned names, symbol table, locals, tables
+0xC0000..        genome: 0xC0000 entry, 0xC0005 symbol table address, 0xC0006 image end
+0xE0000..0xEFFFF frame stack, grows down from 0xF0000
+0xF0000..        return stack, grows up
+0xF8000..        mark stack
+0xFC000..0xFFFF0 data stack, grows down
+```
+
+calls push the arguments left to right and the callee's prologue pops them into its frame. locals live in the frame at `*0xA0000 + slot`. every function leaves exactly one word on the data stack. heap objects have a 6 word header: size, size class, flags, a check word, owner, type.
+
+## how the core works
+
+registers: x19 holds the memory base, x20 the data stack pointer, x21 the return stack pointer, x22 the translation table and x23 the state block (memory, s, r, table, coverage map, Q, G, &J, store hook, install hook, enhancement fallback).
+
+compilation is lazy. the first time control reaches an address, that block is translated from live memory. a block ends at call, jump, ret or halt. a `z` doesn't end it: the not-taken side keeps compiling, which makes superblocks. a literal followed by `c`, `j` or `z` is fused into a constant target. every exit goes through a dispatch stub that checks both stack pointers against their limits (kept in x24 and x25), bounds-checks the target, loads `tab[t]`, and branches straight to it when it's already compiled. otherwise it returns to c, which compiles the block and re-enters. enhancements are inlined: inputs load from the data stack into w0..w15, the optimized micro-ops run in registers with x16 and x17 as scratch, and the outputs go back. an install calls into c and then returns to the loop, which flushes every translation, since code built before the install may have inlined the old version.
+
+self-modification is handled with a byte map of which words some live translation covers. a store checks that byte inline: an uncovered target, the usual case, gets a plain store. a covered target calls the hook, which drops every translation containing that word and makes the jit code return to c at the next instruction, so even patches to the very next word take effect. writing back the same value is a no-op. if the 16 mb code buffer fills, everything is flushed.
+
+the stacks are checked. the data and return stacks are checked at every block exit on all three backends, so the cost is a couple of compares per block rather than per push. a block pushes at most about 1024 words, which the data stack limit leaves room for. overflowing either one stops the cpu with `zy: data stack overflow` or `zy: return stack overflow`. the frame stack is checked in every function prologue, which resets the frame pointer and stops with `zy: frame stack overflow`.
+
+platform: the darwin path uses `MAP_JIT`, `pthread_jit_write_protect_np` and `sys_icache_invalidate`. linux uses rwx mmap and `__builtin___clear_cache`. only linux arm64 has actually been run, under qemu. the darwin path follows apple's documented recipe but hasn't been tested, and under the hardened runtime it also needs the allow-jit entitlement. every host shares the same semantics: shift counts wrap at 32, stores outside memory are ignored, loads outside memory read 0, and jumping outside memory or to an unwired opcode halts.
+
+## test results
+
+`test.sh` passes all 83 checks on x86-64 linux: the fixpoint, an up-to-date `genome.h`, and then every example and feature test on the interpreter, on the arm64 jit under qemu, and on the llvm backend, all with identical output. it also covers joins and fixup frees (with a leak count), `switch` and `?:`, the buddy allocator, several errors in one run, and all three stack overflows. it checks that all 22 programs in `tests/errors/` and all 10 in `tests/typeerrors/` get rejected with the expected message on each backend, that llvm agrees when it compiles every block, and that the self-compile matches byte for byte on all three. separately, 80000 random divisions through enhancements matched the software routine, covering divide by zero, INT_MIN/-1, negatives and the magic-number path for constants.
+
+## open ends
+
+fixed in stage 13 (details in `history/13-gap-fixes`): branch and loop joins, free lists that never merged (now a buddy allocator), missing stack checks, stopping at the first error, macro line numbers, required prototypes, `d*` for storing into borrowed objects, `**` declarations, and `?:` and `switch`. still open:
+
+**untracked aliases.** the analyzer only follows bare variable names, so `let q = p + 0;` or `let c = list[1];` is a plain word nobody tracks, and it dangles once the owner is freed. two cheap fixes, and they combine well. at runtime: don't reuse a freed block right away. `free` would put it on a quarantine list, and the collector's next sweep only releases quarantined blocks that no word points at. the conservative mark already finds such words, so that's maybe 30 lines in rt.zc. a stale alias then reads a dead but intact block, and a second free through it is a no-op, because the header's flags say free. at compile time: now that there are types, a pointer-typed value computed from a tracked variable (`p + k`, `p.field`, `p[i]` when the element is a pointer) can carry a "borrowed from p" mark into the local it's stored in. using that local after `p` dies becomes an error. that's the same machinery children already use.
+
+**the conservative collector.** it scans the whole data stack region, because the vm can't read its own stack pointer, and stale words keep garbage alive a little longer. the fix is one base opcode that pushes the data stack depth, which is trivial in hardware since the register already exists. then the collector scans only the live part. zeroing a frame in the prologue would do the same for the frame stack, at a few words per call.
+
+**coarse invalidation.** a store to a covered word rescans every block, and an install flushes everything. three fixes, in order of payoff. first, index blocks by page (say 64 words): a covered store only looks at the blocks touching its page, and dropping a block only rebuilds the coverage bytes for that block. second, record which enhancement slots each translation inlines, so an install only drops those. third, on llvm, give each block its own resource tracker, so dropped code actually gets freed.
+
+**tiering on arm64.** answered when you asked: a run counter per block costs about 4 instructions per block entry, and a hot block could be relifted to ssa, optimized with the enhancement optimizer, and given registers instead of the memory stack. that's likely 2 to 4x on tight loops, and it would also beat llvm's warm-up on x86. not built yet.
+
+**generics are erased.** a generic function is compiled once, so the type stamped by `new(T)` inside it says `T`, and type arguments have to be one word.
+
+**the rest.** the prescan only knows tags, not types, so a call to a typed function that's defined further down gets `word` as its result type until the definition shows up. the llvm backend compiles one module per block, so it warms up slowly. stores done by enhancements don't invalidate compiled code. a parse word that changes the syntax can confuse the prescan. it only records signatures, though, and a real definition always overrides what the prescan guessed.
+
+---
+
+## transcript
+
+each of my messages is quoted exactly, followed by a summary of the reply.
+
+### 1
+
+> codegolf a tiny cpu vm in C89. the goal is to achieve the lowest character count possible. include an assembler as well (scored separately) and a hello world program (not scored, but elegance and simplicity is a bonus)
+> it must be capable of re-entrant code and a realistically workable instruction set.
+
+**summary:** a two-stack forth-style machine. the vm was 384 bytes: one ternary chain inside `while(o=m[p++])`, the top two stack items cached in `a` and `b`, the program loaded with `read(open(...))` so it needs no headers, and both stacks inside the 65536-word memory. it had 22 opcodes including div and mod, a two-word literal, and jump/call targets popped from the stack. the assembler was 348 bytes and two-pass, using `strcspn` instead of `strchr` so the implicit int return stays safe on 64-bit. hello world was a pointer loop over a string with a zero terminator. re-entrancy was shown with a recursive factorial plus a recursive decimal printer.
+
+### 2
+
+> your cpu should also be realistically close to hardware (translating it to logical circuitry hardware should be fairly easy) and sport an acceptably fast execution (if hypothetically ported to hardware, not in software)
+>
+> assume i/o is handled by two external functions, `char Q()` (getchar) and `void G(char)` (putchar) and a state variable J (boolean, shows if input is empty).
+>
+> don't be afraid to use macros.
+
+**summary:** no reply was sent to this message at the time. it was answered together with message 3.
+
+### 3
+
+> pro tip: if you define a macro as `!o--`, you can save 2 characters per if condition
+> oh and btw, newlines are free
+
+**summary:** used the tip as `#define X !--o?`, with pre-decrement because opcode 0 (halt) is already handled by the loop, and with the `?` folded into the macro and free newlines used as separators. the hardware-oriented redesign: bit 0 of each word is a literal flag, so literals take one cycle like the j1 cpu. div and mod were dropped because they can't finish in one cycle and were replaced by an arithmetic shift right, giving 8 alu ops that decode from 3 bits. every instruction does a fixed amount of work with at most one data memory access, and call and jump share a datapath (`r-=o`). i/o now goes through `Q`, `G` and a `?` op that reads `J`. the result was the vm at 339 bytes and the assembler at 346. the final golfed code:
+
+```c
+#define X !--o?
+int m[1<<16],p,s=65e3,r=6e4,o,a,b;main(c,v)char**v;{read(open(v[1],0),m,s);while(o=m[p++])a=m[s],b=m[s+1],o&1?m[--s]=o>>1:(o/=2,X
+m[s]=m[a]:X
+m[a]=b,s+=2:X
+m[s]=m[s-~a]:X
+s++:X
+m[s]=b,m[s+1]=a:(o-=2)<1?m[r]=p,r-=o,p=a,s++:X
+p=b?p:a,s+=2:X
+p=m[--r]:X
+m[--s]=Q():X
+m[--s]=J:X
+G(a),s++:(m[++s]=X
+b+a:X
+b-a:X
+b*a:X
+b&a:X
+b|a:X
+b^a:X
+b>>a:b<a));}
+```
+
+```c
+char t[9999][99],*o="q@!$_~cjzr,?.+-*&|^><",*q;A[9999],k,i,j,n,P;E(y){n++;write(P,&y,4);}V(char*s){for(j=k;j--&&(*t[j]-58||strcmp(t[j]+1,s)););return~j?A[j]:atoi(s);}main(){while(~scanf("%s",t[k]))k++;for(;P<2;P++)for(n=i=0;i<k;i++)if(*(q=t[i])==34)while(*++q)E(*q);else*q==58?A[i]=n:!q[1]&&o[j=strcspn(o,q)]?E(j*2):*q==35?E(V(q+1)):E(V(q)*2+1);}
+```
+
+### 4
+
+> now let's move in stages. write a compiler that takes this assembler's code and converts it into darwin arm
+
+**summary:** an ungolfed c89 compiler from vm assembly to darwin arm64 assembly. every word got its own label, the image was emitted as an addressable data array, x19/x20/x21 held the memory base and the two stack pointers, and computed jumps went through a table of offsets. a literal followed by a jump became a direct branch. `Q` and `G` went through `sxtb`, since char is signed on apple arm64, and `J` was read with `ldrb`. it was verified by assembling with llvm-mc for darwin, then rewriting to linux with sed and running under qemu, where it matched the vm byte for byte. this version couldn't handle self-modifying code.
+
+### 5
+
+> can you write the assembler in assembly and pair the code with the assembly and the assembler so that it can re-wire itself at runtime? or maybe include an interp for self-modification, otherwise fns are exec'd native
+
+**summary:** both. `aslib.s` is the assembler written in vm assembly as a library (`a.src`, `a.dst`, `a.org`, `a.lab`, then `a.run c`), and with `asmain.s` it's a 568-word standalone assembler. it's byte-identical to the c assembler and reaches a fixpoint when assembling itself. this is also where the `:;comment` trick came from. the compiler became a hybrid. the image is split into basic blocks, each block counts how many of its words differ from the original image, and stores into code go through a slow path that updates the counters. clean blocks run native, while dirty blocks and anything past the image run in an interpreter compiled into the same binary, which hands control back to native code whenever it lands in a clean block. `cc -t` printed `[` and `]` at each switch. the demo rewired a function at runtime to point at freshly assembled code and then restored it.
+
+### 6
+
+> which one do you like more? and which is more performant?
+> keep that one, then port to using llvm ir so that it can be platform independent
+
+**summary:** no reply was sent at the time. the llvm port was dropped when message 7 changed direction. the question was answered at the start of the reply to message 7: the hybrid was the favorite because it kept the vm's semantics exact. the plain compiler was slightly faster on code that never rewrites itself, but it silently ran stale code once anything did. the zygote beats both.
+
+### 7
+
+> can you make it a zygote approach?
+> a minimal core loads first, reads and compiles the program (either wholly or partially, for speed) and replaces it with itself. so it's like a jvm but self-contained and on the same level as itself, where the assembler can itself be modified in-memory to assemble different code. for this we need to ditch llvm
+
+**summary:** the current design, described above. the native core only does jit and glue. it loads the genome (boot loader + assembler, both vm code) at 48000. the boot loader reads source until eof or a backtick, assembles it at 0 and jumps there. compilation is lazy per block, straight from live memory, with superblocks through `z`, fused constant targets, and dispatch chained through a table. invalidation uses the coverage byte map plus a store hook, so self-modified code gets retranslated instead of interpreted. the resident assembler sits at fixed addresses, and `repl.s` rewrites its mnemonic table so `p` means out, then assembles and runs input chunks in a loop, overwriting the same address each time. verified under qemu on linux arm64, including the self-hosted assembler running on the zygote. about 4x faster than the golfed interpreter.
+
+### 8
+
+> damn dawg you made an entire baremetal os?
+>
+> let's move to cowork. pack everything up alongside a transcript of every message i've sent and your own notes on what you've implemented in an md file, with the code, so i can move it.
+
+**summary:** not quite an os. it's a userland runtime. it still runs on darwin or linux, uses their mmap for executable memory, and gets i/o from the host through `Q`, `G` and `J`. there's no scheduler, no drivers and no hardware access, so a closer description is a tiny self-hosting jit, in the spirit of a jvm. the first packing attempt bundled every stage's code with a full test script.
+
+### 9
+
+> nono we don't need all the code, just the recent ones. my msgs and your summaries are more important and all should be there
+
+**summary:** this package. only the zygote stack plus its examples and tests are included, and earlier stages appear only as summaries. the golfed reference vm and assembler are inlined under message 3, because they define the instruction set.
+
+### 10
+
+> we're gonna make this thing cooler. make the syntax C-like whilst still keeping the forth capabilities like super-homiconicity and the likes, add explicit and automatic gc (use a fast approach) and memory management that looks like this:
+> every heap object has a classifier u m d, up middle down. up means the object will die at the scope above (becomes m when returned to the parent scope, and it must be returned and cannot be discarded). m means it must be used here and can be passed down (but once it's recasted as u or d it can't be casted back to m in this scope). d means the variable is passed down, and its lifetime ends after it's given for the first time to a scope lower than the current one.
+> ask me questions to clarify this approach, then add it to the code and also add a simple static analyzer which checks these lifetimes
+
+my answers to the clarifying questions, exactly:
+
+> scope: every { } block
+>
+> lending an m object to a callee: borrow, no escape (Recommended)
+>
+> storing a heap object inside another object or a global: container gets ownership. putting a value inside a container requires its umd to match the parent, and from then on, the umd for that is also inherited from the parent (as in if a parent m is casted to d, so is the child heap object)
+>
+> gc: free lists + mark-sweep (Recommended)
+>
+> where the compiler lives: resident in vm code. bootstrap it step by step, by writing a c-like in core.c and then rewriting the compiler inside the c-like. also bring back llvm if you think it'll make your job easier
+>
+> homoiconic features: parse words, quoted code blocks, inline stack code, patchable compiler tables
+>
+> how an inner block hands a u object up: expression and assign, both
+>
+> when the analyzer runs: inside the compiler but can be turned off if the code requests it
+
+**summary:** the genome is now zc, a typeless c-like language, described above. stage 0 is `zc0.c` (kept as its own file next to core.c rather than inside it, so the runtime still has one native file), and the resident compiler is `src/compiler.zc` plus `src/rt.zc`, which reached a byte-identical fixpoint compiling itself. llvm wasn't brought back, since the target is the vm itself. memory went to 1m words, and core.c gained an interpreter for non-arm64 hosts. calls i made without asking: tags go on signatures (`fn f(m a, d b) -> u`) and recasts are `x as u` / `x as d`; a d object touched inside an inner block moves into that block; storing into a borrowed object, a global or untracked memory needs `as d`; handing a u up by assignment only reaches the directly enclosing block; unchecked code gives its objects to the collector. the old asm genome moved to `legacy/`.
+
+### 11
+
+> progress report?
+> add types please :)
+> mostly as a compiler primitive though, plus type-inspection via reflection
+> and a small optional typechecker (default off)
+> oh and keep the stuff you write as a history scrapbook
+> if it helps, add a path to the hardware which is called "virtual enhancements", and allows up to 512 custom operations to be compiled down via jit into hardware-level speeds and interoped directly into a fast path in the vm to become essentially custom wiring. useful for division and other stuff as a dynamic runtime path
+
+my answers to the clarifying questions, exactly:
+
+> types: words + structs + generics
+>
+> reflection: runtime type of heap objects, function signatures, typeof at compile time
+>
+> how an enhancement is defined: either actual C or llvm ir code or vm code or micro-ops passed through an optimizer. since for example, micro-ops and vm code are not sufficient for optimizing things like division
+>
+> scrapbook: notes + code snapshots
+
+**summary:** the progress report said the previous round was finished and shipped. i then laid out a plan where the core would compile c or llvm ir enhancement sources at runtime with the host toolchain and load the result. part of that reply was stopped by a safety check before it finished, so i stopped and checked in instead of building it.
+
+### 12
+
+> also make the umd syntax like `type.u name`, and casting is multiplication `u*name`
+> ideally i'd prefer memory to be unlimited words growing until system oom, but 1m is fine
+> core.c plain interp is also nice
+> zc0.c own file is fine
+> i mentioned llvm for portability to non-arm targets
+> yes, d object semantic that was intended
+> u object hands up one block and becomes an m, that's fine. the code can make it a u or a d or whatever
+> explain your gaps more
+>
+> wait why safety check? what's wrong with that
+
+my answers to the clarifying questions, exactly:
+
+> declarations: c-style, var -> let
+>
+> tags on untyped values and the names u, m, d: names reserved, bare .u allowed, untype is m by default
+>
+> llvm: llvm jit backend (Recommended)
+
+**summary:** on the safety check: nothing was wrong with the request. my best guess was that it tripped on the plan for a program inside the vm handing source text to the system compiler and loading the result into the running process, since that pattern also shows up in malware. with llvm meant for portability, that path wasn't needed. the gaps got the longer explanations that are now under open ends above. then the round itself:
+
+**syntax.** declarations are c-style (`int x`, `*node.m p`), `let` replaces `var` for untyped and inferred declarations, tags are `.u .m .d` after the type or on their own, recasts are `u*x` / `d*x` / `m*x`, `u m d` are reserved, and an untagged parameter counts as an m lend.
+
+**types.** a compiler primitive: hash-consed records with structs, generic structs and functions, fixed arrays, function types, `typeof`/`sizeof`, `as` casts and a reflection api, with object headers carrying their type. the typechecker is off by default and turned on with `typecheck on;`.
+
+**virtual enhancements.** opcode 21 installs, 22 to 533 are the slots. micro-op recipes and lifted vm code go through an optimizer in the core (folding, cse, dce, multiply-high division by constants) and get inlined by both jits. the language's own `/ % <<` now run on them.
+
+**backends.** a tiered llvm backend (`-DZYLLVM`) for non-arm hosts.
+
+**bootstrap and history.** it still reaches its fixpoint on all three backends. `history/` holds notes for every stage and code from stages 7, 10 and this one (in 11-types-enhancements).
+
+### 13
+
+> gaps
+> 1. when there's a var state change to d, mark that var as dead by default for any other scope that can access it afterwards. u is fine since it just returns
+> 2. any suggestions for a cheap fix?
+> 3. it's fine, rare occurrence (probably?), suggest a fix
+> 4. fix that
+> 5. suggest a fix
+> 6. fix
+> 7. fix
+
+**summary:** the numbers followed the gap list from my previous chat message. here's what each one got.
+
+**1. joins.** a variable that became d, or was given away, on any path is dead after the join, and fixup code frees it on the paths that still own it. a loop's exit state is the join of its breaks and its normal exit. giving something away on a path that loops back is still an error. u and borrows don't get the dead treatment.
+
+**2, 3 and 5.** suggestions only, now under open ends: a quarantine on reuse plus "borrowed from" marks on pointer-typed values for aliases, a stack-depth opcode for the collector, and page-indexed invalidation plus per-slot install tracking for the jit.
+
+**4. heap.** a buddy allocator.
+
+**6. stack checks.** all three stacks are checked: data and return at every block exit on all backends, and frames in every prologue.
+
+**7. the small stuff.** error recovery with up to 20 reported errors, line numbers carried in token lists, a signature prescan over the whole unit so prototypes are optional, storing into a borrowed object moving the object automatically, `?:`, and go-style `switch`. on the side, a 4-token lookahead fixed `**` declarations.
+
+### 14
+
+> how costly is it if we add a counter to each block to see how many times it runs, then run the optimizer on it if it's a hot path?
+
+> continue
+
+**summary:** answered without building anything. about 4 instructions per block entry while a block is being counted, and nothing once its optimized translation replaces it. the optimizing pass would reuse the enhancement lifter, optimizer and register allocator. lifting whole blocks would need jz side exits and barriers at calls and i/o. compiling a block that way takes microseconds, against milliseconds for llvm, and keeping values in registers instead of the memory stack likely gives 2 to 4x on tight loops. it's listed under open ends. then the gap fixes continued.
diff --git a/docs/history/13-gap-fixes/code/core.c b/docs/history/13-gap-fixes/code/core.c
new file mode 100644
index 0000000..ce353c8
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/core.c
@@ -0,0 +1,1183 @@
+/* zygote core: puts the genome (the zc compiler and its runtime, both vm code)
+   into memory and runs it. on arm64, every block of vm code is translated to
+   arm64 the first time it is reached, straight from live memory. stores that
+   land on translated words throw those translations away, so code that
+   rewrites itself, including the resident compiler, just gets retranslated
+   on the next visit. on other hosts (or with -DZYINTERP) a plain interpreter
+   with the same semantics runs instead. ZYTRACE=1 logs translations on stderr. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(__aarch64__) && !defined(ZYINTERP)
+#define ZYJIT 1
+#include <sys/mman.h>
+#ifdef __APPLE__
+#include <pthread.h>
+#include <libkern/OSCacheControl.h>
+#endif
+#endif
+#include "genome.h"
+
+#ifndef JTYPE
+#define JTYPE char
+#endif
+char Q(void);
+void G(char);
+extern JTYPE J;
+
+#define MW (1 << 20)	/* memory, in words */
+#define DS0 (MW - 16)	/* data stack grows down from here */
+#define RS0 0xF0000	/* return stack grows up from here */
+#define DSLIM (0xFC000 + 1100)	/* data stack overflows below this (a block pushes at most ~1024) */
+#define RSLIM (0xF8000 - 8)	/* return stack overflows above this */
+/* why the cpu stopped, when it wasn't a halt */
+static int stopped(int p)
+{
+	if (p == MW + 1) { fprintf(stderr, "zy: data stack overflow\n"); return 2; }
+	if (p == MW + 2) { fprintf(stderr, "zy: return stack overflow\n"); return 2; }
+	return 0;
+}
+#define CODEW (4 << 20)	/* 16 MB of code, in instruction words */
+#define MAXB 65536
+#define BLKW 1024	/* longest block, in vm words */
+
+static int m[MW];
+static int trace;
+
+/* ---- virtual enhancements ----
+   up to 512 custom opcodes (22 .. 533), wired in at runtime by the install
+   opcode (21). an enhancement is a short program over native micro-ops,
+   written either as a recipe (text) or as straight-line vm code that gets
+   lifted. both become ssa, go through the optimizer below, and then run in
+   the interpreter or get inlined by the jit as native code. */
+#define NENH 512
+#define XOP0 22
+enum { U_LI, U_MOV, U_ADD, U_SUB, U_MUL, U_SDIV, U_UDIV, U_SREM, U_UREM, U_AND, U_OR, U_XOR,
+	U_SHL, U_SHR, U_SAR, U_NEG, U_NOT, U_LT, U_LTU, U_EQ, U_NE, U_MIN, U_MAX, U_MINU, U_MAXU,
+	U_MULHS, U_MULHU, U_CLZ, U_ABS, U_SEL, U_LD, U_ST, U_N };
+static const char *unames[U_N] = { "li", "mov", "add", "sub", "mul", "sdiv", "udiv", "srem", "urem",
+	"and", "or", "xor", "shl", "shr", "sar", "neg", "not", "lt", "ltu", "eq", "ne", "min", "max",
+	"minu", "maxu", "mulhs", "mulhu", "clz", "abs", "sel", "ld", "st" };
+static const signed char uarity[U_N] = { 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2 };
+typedef struct { int op, d, a, b, c, imm; } Uop;	/* ssa: d is a fresh value, a b c are values */
+typedef struct {
+	int live, kind, nin, nout, n, nv, out[8];
+	Uop *u;
+	signed char *reg;	/* physical register per value, for the jit; 0 if it didn't fit */
+} Enh;
+static Enh enh[NENH];
+static int need_flush;
+
+#define MAXUOP 4096
+static Uop ub[MAXUOP]; static int un, unv, uerr;	/* the program being built */
+static int unew(int op, int a, int b, int c, int imm)
+{
+	Uop *u;
+	if (un >= MAXUOP) { uerr = -5; return 0; }
+	u = &ub[un++]; u->op = op; u->d = unv++; u->a = a; u->b = b; u->c = c; u->imm = imm;
+	return u->d;
+}
+static int mread(int a) { return (unsigned)a < MW ? m[a] : 0; }
+
+/* recipe text: one statement per line or per ';'
+     r0 = sdiv r0 r1      dst = op operands, operands are rN, parameter names or numbers
+     r2 = r0              a copy, or a number
+     st r1 r0             memory[r1] = r0
+   inputs arrive in r0.. (and under the parameter names), outputs leave from r0.. */
+static int parse_recipe(int src, int names, int nin, int nout, int *out)
+{
+	int cur[16], i, p = src, n, k, op, args[3], na, dst, isst;
+	char tok[8][32]; int nt;
+	for (i = 0; i < 16; i++) cur[i] = i < nin ? i : -1;
+	for (;;) {
+		/* read one statement into tokens */
+		nt = 0;
+		for (;;) {
+			int c = mread(p);
+			while (c == ' ' || c == '\t' || c == '\r') c = mread(++p);
+			if (!c || c == '\n' || c == ';') break;
+			if (c == '=') { if (nt < 8) strcpy(tok[nt++], "="); p++; continue; }
+			n = 0;
+			while (c && c != ' ' && c != '\t' && c != '\n' && c != ';' && c != '=' && c != '\r') { if (n < 31) tok[nt < 8 ? nt : 7][n++] = (char)c; c = mread(++p); }
+			if (nt < 8) tok[nt++][n] = 0;
+		}
+		if (nt) {
+			isst = !strcmp(tok[0], "st");
+			if (!isst && (nt < 3 || strcmp(tok[1], "="))) return -2;
+			/* destination register */
+			dst = -1;
+			if (!isst) {
+				if (tok[0][0] == 'r' && tok[0][1] >= '0' && tok[0][1] <= '9') dst = atoi(tok[0] + 1);
+				else for (i = 0; i < nin && names; i++) {
+					int s = mread(names + i), j = 0;
+					while (mread(s + j) && mread(s + j) == (unsigned char)tok[0][j]) j++;
+					if (!mread(s + j) && !tok[0][j]) dst = i;
+				}
+				if (dst < 0 || dst > 15) return -2;
+			}
+			k = isst ? 1 : 2;	/* first token after "=" (or after st) */
+			op = -1;
+			if (!isst && nt > 3) { for (i = 0; i < U_N; i++) if (!strcmp(tok[k], unames[i])) op = i; if (op < 0) return -2; k++; }
+			if (isst) op = U_ST;
+			na = 0;
+			for (; k < nt; k++) {
+				char *t = tok[k], *e; int v = -1;
+				if (na >= 3) return -2;
+				if (t[0] == 'r' && t[1] >= '0' && t[1] <= '9') { int r = atoi(t + 1); if (r > 15) return -2; if (cur[r] < 0) cur[r] = unew(U_LI, 0, 0, 0, 0); v = cur[r]; }
+				else if ((t[0] >= '0' && t[0] <= '9') || t[0] == '-') { long x = strtol(t, &e, 0); if (*e) return -2; v = unew(U_LI, 0, 0, 0, (int)x); }
+				else {
+					for (i = 0; i < nin && names; i++) {
+						int s = mread(names + i), j = 0;
+						while (mread(s + j) && mread(s + j) == (unsigned char)t[j]) j++;
+						if (!mread(s + j) && !t[j]) v = cur[i] < 0 ? (cur[i] = unew(U_LI, 0, 0, 0, 0)) : cur[i];
+					}
+					if (v < 0) return -2;
+				}
+				args[na++] = v;
+			}
+			if (op < 0) {	/* x = y */
+				if (na != 1) return -2;
+				cur[dst] = args[0];
+			} else {
+				if (na != (op == U_LI ? 0 : uarity[op])) {
+					if (!(op == U_LI && na == 1)) return -2;
+				}
+				if (op == U_LI) cur[dst] = args[0];
+				else if (op == U_ST) unew(U_ST, args[0], args[1], 0, 0);
+				else cur[dst] = unew(op, args[0], na > 1 ? args[1] : 0, na > 2 ? args[2] : 0, 0);
+			}
+			if (uerr) return uerr;
+		}
+		if (!mread(p)) break;
+		p++;
+	}
+	for (i = 0; i < nout; i++) { if (cur[i] < 0) cur[i] = unew(U_LI, 0, 0, 0, 0); out[i] = cur[i]; }
+	return uerr;
+}
+
+/* straight-line vm code from addr up to its ret, run symbolically */
+static int lift_vm(int a, int len, int nin, int nout, int *out)
+{
+	int st[256], sp = 0, i, w, k, x, y;
+	for (i = 0; i < nin; i++) st[sp++] = i;
+	for (i = 0; i < len; i++) {
+		w = mread(a + i);
+		if (w & 1) { if (sp >= 256) return -4; st[sp++] = unew(U_LI, 0, 0, 0, w >> 1); continue; }
+		k = w / 2;
+		if (k == 9) break;
+		switch (k) {
+		case 1: if (sp < 1) return -4; st[sp - 1] = unew(U_LD, st[sp - 1], 0, 0, 0); break;
+		case 2: if (sp < 2) return -4; unew(U_ST, st[sp - 1], st[sp - 2], 0, 0); sp -= 2; break;
+		case 3:	/* pick needs a constant index */
+			if (sp < 1) return -4;
+			x = st[sp - 1];
+			if (x < nin) return -4;
+			{ int j; for (j = 0; j < un && ub[j].d != x; j++); if (j == un || ub[j].op != U_LI) return -4; y = ub[j].imm; }
+			if (y < 0 || y >= sp - 1) return -4;
+			st[sp - 1] = st[sp - 2 - y];
+			break;
+		case 4: if (sp < 1) return -4; sp--; break;
+		case 5: if (sp < 2) return -4; x = st[sp - 1]; st[sp - 1] = st[sp - 2]; st[sp - 2] = x; break;
+		case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: {
+			static const int map[] = { U_ADD, U_SUB, U_MUL, U_AND, U_OR, U_XOR, U_SAR, U_LT };
+			if (sp < 2) return -4;
+			x = st[sp - 1]; y = st[sp - 2]; sp -= 2;
+			st[sp++] = unew(map[k - 13], y, x, 0, 0);
+			break; }
+		default: return -4;	/* control flow, i/o and other enhancements don't lift */
+		}
+		if (uerr) return uerr;
+	}
+	if (sp != nout) return -4;
+	for (i = 0; i < nout; i++) out[i] = st[i];
+	return uerr;
+}
+
+/* ---- the optimizer ----
+   one forward pass of copy propagation, constant folding, algebraic
+   simplification, division by constants (the multiply-high trick) and
+   common subexpression elimination, then dead code removal. */
+static int ev(int op, int a, int b, int c)
+{
+	unsigned ua = (unsigned)a, ub_ = (unsigned)b;
+	switch (op) {
+	case U_ADD: return (int)(ua + ub_);
+	case U_SUB: return (int)(ua - ub_);
+	case U_MUL: return (int)(ua * ub_);
+	case U_SDIV: return b == 0 ? 0 : (a == (int)0x80000000 && b == -1) ? a : a / b;
+	case U_UDIV: return b == 0 ? 0 : (int)(ua / ub_);
+	case U_SREM: return b == 0 ? a : (a == (int)0x80000000 && b == -1) ? 0 : a % b;
+	case U_UREM: return b == 0 ? a : (int)(ua % ub_);
+	case U_AND: return a & b;
+	case U_OR: return a | b;
+	case U_XOR: return a ^ b;
+	case U_SHL: return (int)(ua << (b & 31));
+	case U_SHR: return (int)(ua >> (b & 31));
+	case U_SAR: return a >> (b & 31);
+	case U_NEG: return (int)(0u - ua);
+	case U_NOT: return ~a;
+	case U_LT: return a < b;
+	case U_LTU: return ua < ub_;
+	case U_EQ: return a == b;
+	case U_NE: return a != b;
+	case U_MIN: return a < b ? a : b;
+	case U_MAX: return a > b ? a : b;
+	case U_MINU: return ua < ub_ ? a : b;
+	case U_MAXU: return ua > ub_ ? a : b;
+	case U_MULHS: return (int)(((long long)a * (long long)b) >> 32);
+	case U_MULHU: return (int)(((unsigned long long)ua * ub_) >> 32);
+	case U_CLZ: { int n = 0; if (!ua) return 32; while (!(ua & 0x80000000u)) { ua <<= 1; n++; } return n; }
+	case U_ABS: return a < 0 ? (int)(0u - ua) : a;
+	case U_SEL: return a ? b : c;
+	}
+	return 0;
+}
+static void smagic(int d, int *mul, int *sh)	/* hacker's delight, signed */
+{
+	const unsigned two31 = 0x80000000u;
+	unsigned ad = d < 0 ? 0u - (unsigned)d : (unsigned)d, t = two31 + ((unsigned)d >> 31);
+	unsigned anc = t - 1 - t % ad, q1 = two31 / anc, r1 = two31 - q1 * anc, q2 = two31 / ad, r2 = two31 - q2 * ad, delta;
+	int p = 31;
+	do {
+		p++;
+		q1 *= 2; r1 *= 2; if (r1 >= anc) { q1++; r1 -= anc; }
+		q2 *= 2; r2 *= 2; if (r2 >= ad) { q2++; r2 -= ad; }
+		delta = ad - r2;
+	} while (q1 < delta || (q1 == delta && r1 == 0));
+	*mul = (int)(q2 + 1); if (d < 0) *mul = -*mul;
+	*sh = p - 32;
+}
+static void umagic(unsigned d, unsigned *mul, int *add, int *sh)	/* hacker's delight, unsigned */
+{
+	unsigned nc = 0xFFFFFFFFu - (0u - d) % d, q1, r1, q2, r2, delta;
+	int p = 31;
+	*add = 0;
+	q1 = 0x80000000u / nc; r1 = 0x80000000u - q1 * nc;
+	q2 = 0x7FFFFFFFu / d; r2 = 0x7FFFFFFFu - q2 * d;
+	do {
+		p++;
+		if (r1 >= nc - r1) { q1 = 2 * q1 + 1; r1 = 2 * r1 - nc; } else { q1 = 2 * q1; r1 = 2 * r1; }
+		if (r2 + 1 >= d - r2) { if (q2 >= 0x7FFFFFFFu) *add = 1; q2 = 2 * q2 + 1; r2 = 2 * r2 + 1 - d; }
+		else { if (q2 >= 0x80000000u) *add = 1; q2 = 2 * q2; r2 = 2 * r2 + 1; }
+		delta = d - 1 - r2;
+	} while (p < 64 && (q1 < delta || (q1 == delta && r1 == 0)));
+	*mul = q2 + 1; *sh = p - 32;
+}
+
+static Uop ob[MAXUOP]; static int on, onv;
+static int *omap, *isk, *kv;	/* old value -> new value; constness of new values */
+static int pure(int op) { return op != U_LD && op != U_ST; }
+static int ispow2(unsigned x) { return x && !(x & (x - 1)); }
+static int lg2(unsigned x) { int n = 0; while (x > 1) { x >>= 1; n++; } return n; }
+static int oe(int op, int a, int b, int c, int imm);
+static int K(int v) { return oe(U_LI, 0, 0, 0, v); }
+static int raw(int op, int a, int b, int c, int imm)
+{
+	Uop *u; int i;
+	if (pure(op))	/* cse */
+		for (i = 0; i < on; i++) {
+			u = &ob[i];
+			if (u->op == op && u->a == a && u->b == b && u->c == c && u->imm == imm) return u->d;
+		}
+	if (on >= MAXUOP) { uerr = -5; return 0; }
+	u = &ob[on++]; u->op = op; u->d = onv++; u->a = a; u->b = b; u->c = c; u->imm = imm;
+	isk[u->d] = op == U_LI; kv[u->d] = imm;
+	return u->d;
+}
+static int sdivk(int a, int d)	/* a / d for a constant d, no divide instruction */
+{
+	int mul, sh, q, t;
+	if (d == 1) return a;
+	if (d == -1) return oe(U_NEG, a, 0, 0, 0);
+	if (d == (int)0x80000000) return oe(U_EQ, a, K(d), 0, 0);
+	if (ispow2((unsigned)(d < 0 ? -d : d))) {
+		int k = lg2((unsigned)(d < 0 ? -d : d));
+		t = oe(U_SAR, a, K(31), 0, 0);
+		t = oe(U_SHR, t, K(32 - k), 0, 0);
+		q = oe(U_SAR, oe(U_ADD, a, t, 0, 0), K(k), 0, 0);
+		return d < 0 ? oe(U_NEG, q, 0, 0, 0) : q;
+	}
+	smagic(d, &mul, &sh);
+	q = oe(U_MULHS, a, K(mul), 0, 0);
+	if (d > 0 && mul < 0) q = oe(U_ADD, q, a, 0, 0);
+	if (d < 0 && mul > 0) q = oe(U_SUB, q, a, 0, 0);
+	if (sh) q = oe(U_SAR, q, K(sh), 0, 0);
+	return oe(U_ADD, q, oe(U_SHR, q, K(31), 0, 0), 0, 0);
+}
+static int udivk(int a, unsigned d)
+{
+	unsigned mul; int add, sh, t;
+	if (d == 1) return a;
+	if (ispow2(d)) return oe(U_SHR, a, K(lg2(d)), 0, 0);
+	if (d > 0x80000000u) return oe(U_XOR, oe(U_LTU, a, K((int)d), 0, 0), K(1), 0, 0);	/* a >= d */
+	umagic(d, &mul, &add, &sh);
+	t = oe(U_MULHU, a, K((int)mul), 0, 0);
+	if (!add) return sh ? oe(U_SHR, t, K(sh), 0, 0) : t;
+	t = oe(U_ADD, oe(U_SHR, oe(U_SUB, a, t, 0, 0), K(1), 0, 0), t, 0, 0);
+	return sh > 1 ? oe(U_SHR, t, K(sh - 1), 0, 0) : t;
+}
+static int oe(int op, int a, int b, int c, int imm)
+{
+	int ka, kb, A, B;
+	if (op == U_LI) return raw(U_LI, 0, 0, 0, imm);
+	if (op == U_MOV) return a;
+	if (op == U_LD || op == U_ST) return raw(op, a, b, 0, 0);
+	ka = isk[a]; kb = uarity[op] > 1 && isk[b];
+	A = kv[a]; B = kv[b];
+	/* everything constant: fold */
+	if (ka && (uarity[op] < 2 || kb) && (uarity[op] < 3 || isk[c])) return K(ev(op, A, B, kv[c]));
+	/* constants go right for commutative ops */
+	if (ka && !kb && (op == U_ADD || op == U_MUL || op == U_AND || op == U_OR || op == U_XOR || op == U_EQ || op == U_NE ||
+		op == U_MIN || op == U_MAX || op == U_MINU || op == U_MAXU || op == U_MULHS || op == U_MULHU)) {
+		int t = a; a = b; b = t; kb = 1; B = A; ka = 0;
+	}
+	if (op == U_SEL && ka) return A ? b : c;
+	if (op == U_SEL && b == c) return b;
+	if (kb) switch (op) {
+	case U_ADD: case U_SUB: case U_OR: case U_XOR: case U_SHL: case U_SHR: case U_SAR:
+		if (!B || (op >= U_SHL && op <= U_SAR && !(B & 31))) return a;
+		break;
+	case U_MUL:
+		if (B == 0) return K(0);
+		if (B == 1) return a;
+		if (B == -1) return oe(U_NEG, a, 0, 0, 0);
+		if (ispow2((unsigned)B)) return oe(U_SHL, a, K(lg2((unsigned)B)), 0, 0);
+		break;
+	case U_AND: if (B == 0) return K(0); if (B == -1) return a; break;
+	case U_SDIV: if (B == 0) return K(0); return sdivk(a, B);
+	case U_SREM: if (B == 0) return a; if (B == 1 || B == -1) return K(0);
+		return oe(U_SUB, a, oe(U_MUL, sdivk(a, B), b, 0, 0), 0, 0);
+	case U_UDIV: if (B == 0) return K(0); return udivk(a, (unsigned)B);
+	case U_UREM: if (B == 0) return a;
+		if (ispow2((unsigned)B)) return oe(U_AND, a, K(B - 1), 0, 0);
+		return oe(U_SUB, a, oe(U_MUL, udivk(a, (unsigned)B), b, 0, 0), 0, 0);
+	}
+	if (a == b && uarity[op] == 2) {
+		if (op == U_SUB || op == U_XOR || op == U_LT || op == U_LTU || op == U_NE) return K(0);
+		if (op == U_AND || op == U_OR || op == U_MIN || op == U_MAX || op == U_MINU || op == U_MAXU) return a;
+		if (op == U_EQ) return K(1);
+	}
+	return raw(op, a, b, c, 0);
+}
+/* runs the optimizer over ub[0..un) with nin inputs; leaves the result in e */
+static int optimize(Enh *e, int nin, int *out, int nout)
+{
+	int i, *live, n = 0;
+	static int omap_[MAXUOP + 16], isk_[MAXUOP * 4], kv_[MAXUOP * 4];
+	omap = omap_; isk = isk_; kv = kv_;
+	on = 0; onv = nin;
+	for (i = 0; i < nin; i++) { omap[i] = i; isk[i] = 0; }
+	for (i = 0; i < un && !uerr; i++) {
+		Uop *u = &ub[i];
+		int a = uarity[u->op] > 0 || u->op == U_ST || u->op == U_LD ? omap[u->a] : 0;
+		int b = uarity[u->op] > 1 || u->op == U_ST ? omap[u->b] : 0;
+		int c = uarity[u->op] > 2 ? omap[u->c] : 0;
+		if (u->op == U_ST) oe(U_ST, a, b, 0, 0);
+		else omap[u->d] = oe(u->op, a, b, c, u->imm);
+	}
+	if (uerr) return uerr;
+	/* dead code: outputs and stores are live */
+	live = calloc(onv + 1, sizeof *live);
+	for (i = 0; i < nout; i++) { e->out[i] = omap[out[i]]; live[e->out[i]] = 1; }
+	for (i = on; i--;) {
+		Uop *u = &ob[i];
+		if (u->op != U_ST && !live[u->d]) { u->op = -1; continue; }
+		if (uarity[u->op] > 0 || u->op == U_ST || u->op == U_LD) live[u->a] = 1;
+		if (uarity[u->op] > 1 || u->op == U_ST) live[u->b] = 1;
+		if (uarity[u->op] > 2) live[u->c] = 1;
+	}
+	free(live);
+	e->u = malloc((on + 1) * sizeof(Uop));
+	for (i = 0; i < on; i++) if (ob[i].op >= 0) e->u[n++] = ob[i];
+	e->n = n; e->nv = onv; e->nin = nin; e->nout = nout;
+	return 0;
+}
+/* run an installed enhancement on a downward-growing stack; returns the new top */
+static int *xexec(Enh *e, int *sp)
+{
+	int vb[256], *v = e->nv <= 256 ? vb : malloc(e->nv * sizeof(int)), i, j;
+	for (j = 0; j < e->nin; j++) v[j] = sp[e->nin - 1 - j];
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i];
+		switch (u->op) {
+		case U_LI: v[u->d] = u->imm; break;
+		case U_LD: v[u->d] = mread(v[u->a]); break;
+		case U_ST: if ((unsigned)v[u->a] < MW) m[v[u->a]] = v[u->b]; break;
+		default: v[u->d] = ev(u->op, v[u->a], v[u->b], v[u->c]);
+		}
+	}
+	sp += e->nin - e->nout;
+	for (j = 0; j < e->nout; j++) sp[e->nout - 1 - j] = v[e->out[j]];
+	if (v != vb) free(v);
+	return sp;
+}
+static void xdump(int slot, Enh *e)
+{
+	int i;
+	fprintf(stderr, "enh %d: %d in, %d out, %d ops\n", slot, e->nin, e->nout, e->n);
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i];
+		if (u->op == U_ST) fprintf(stderr, "  st v%d v%d\n", u->a, u->b);
+		else if (u->op == U_LI) fprintf(stderr, "  v%d = %d\n", u->d, u->imm);
+		else { fprintf(stderr, "  v%d = %s v%d", u->d, unames[u->op], u->a); if (uarity[u->op] > 1) fprintf(stderr, " v%d", u->b); if (uarity[u->op] > 2) fprintf(stderr, " v%d", u->c); fprintf(stderr, "\n"); }
+	}
+	for (i = 0; i < e->nout; i++) fprintf(stderr, "  out%d = v%d\n", i, e->out[i]);
+}
+/* registers for the jit: values live in w0..w15, straight-line linear scan.
+   if they don't fit, reg stays 0 and the jit calls the interpreter instead. */
+static void regalloc(Enh *e)
+{
+	int *last = malloc(e->nv * sizeof(int)), i, j, k, fr = 0xffff;
+	signed char *r = malloc(e->nv);
+	for (i = 0; i < e->nv; i++) { last[i] = -2; r[i] = -1; }
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i];
+		if (uarity[u->op] > 0 || u->op == U_ST || u->op == U_LD) last[u->a] = i;
+		if (uarity[u->op] > 1 || u->op == U_ST) last[u->b] = i;
+		if (uarity[u->op] > 2) last[u->c] = i;
+	}
+	for (i = 0; i < e->nout; i++) last[e->out[i]] = e->n;
+#define TAKE(v) do { for (k = 0; k < 16 && !(fr >> k & 1); k++); if (k == 16) goto fail; fr &= ~(1 << k); r[v] = (signed char)k; } while (0)
+	for (j = 0; j < e->nin; j++) if (last[j] >= -1 && last[j] != -2) TAKE(j);
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i]; int ops[3], no = 0;
+		if (uarity[u->op] > 0 || u->op == U_ST || u->op == U_LD) ops[no++] = u->a;
+		if (uarity[u->op] > 1 || u->op == U_ST) ops[no++] = u->b;
+		if (uarity[u->op] > 2) ops[no++] = u->c;
+		for (j = 0; j < no; j++) if (last[ops[j]] == i && r[ops[j]] >= 0 && (fr >> r[ops[j]] & 1) == 0) fr |= 1 << r[ops[j]];
+		if (u->op != U_ST) TAKE(u->d);
+		if (u->op != U_ST && last[u->d] == -2) fr |= 1 << r[u->d];	/* never used */
+	}
+#undef TAKE
+	free(last); e->reg = r; return;
+fail:
+	free(last); free(r); e->reg = 0;
+}
+/* the install opcode. descriptor: slot, kind (0 recipe, 1 vm code), inputs,
+   outputs, payload address, payload length, parameter names (or 0).
+   returns 0, or -1 bad descriptor, -2 recipe syntax, -4 code doesn't lift,
+   -5 too big. */
+static int install(int d)
+{
+	int slot = mread(d), kind = mread(d + 1), nin = mread(d + 2), nout = mread(d + 3);
+	int pay = mread(d + 4), len = mread(d + 5), names = mread(d + 6), out[8], r;
+	Enh ne;
+	if ((unsigned)slot >= NENH || (unsigned)nin > 8 || (unsigned)nout > 8 || (kind != 0 && kind != 1)) return -1;
+	un = 0; unv = nin; uerr = 0;
+	r = kind == 0 ? parse_recipe(pay, names, nin, nout, out) : lift_vm(pay, len, nin, nout, out);
+	if (r) { if (trace) fprintf(stderr, "enh %d: install failed (%d)\n", slot, r); return r; }
+	memset(&ne, 0, sizeof ne);
+	if ((r = optimize(&ne, nin, out, nout))) return r;
+	ne.kind = kind; ne.live = 1;
+	regalloc(&ne);
+	if (enh[slot].live) { free(enh[slot].u); free(enh[slot].reg); }
+	enh[slot] = ne;
+	need_flush = 1;
+	if (trace) xdump(slot, &enh[slot]);
+	return 0;
+}
+#ifdef ZYJIT
+static unsigned char cov[MW];	/* 1 if a live translation covers the word */
+static void *tab[MW];		/* vm address -> translation */
+static struct { int a, b; } bl[MAXB];	/* live translations cover [a,b); a < 0 is dead */
+static int nbl;
+static unsigned *code, *cp, *x_enter, *x_exit, *x_disp, *x_first;
+static long S[13];	/* m, s, r, tab, cov, Q, G, &J, store hook, install, enhancement fallback, stack limits */
+
+enum { W0 = 0, W1 = 1, X9 = 9, X10, X11, M = 19, SP = 20, RP = 21, TAB = 22, ST = 23 };
+
+static void E(unsigned x) { *cp++ = x; }
+static void li(int d, int v)
+{
+	unsigned u = (unsigned)v;
+	E(0x52800000 | (u & 0xffff) << 5 | d);
+	if (u >> 16) E(0x72a00000 | (u >> 16) << 5 | d);
+}
+static void ldr_post(int t, int n, int i) { E(0xb8400400 | (i & 0x1ff) << 12 | n << 5 | t); }
+static void ldr_pre(int t, int n, int i) { E(0xb8400c00 | (i & 0x1ff) << 12 | n << 5 | t); }
+static void str_pre(int t, int n, int i) { E(0xb8000c00 | (i & 0x1ff) << 12 | n << 5 | t); }
+static void str_post(int t, int n, int i) { E(0xb8000400 | (i & 0x1ff) << 12 | n << 5 | t); }
+static void ldr_u(int t, int n, int o) { E(0xb9400000 | (o / 4) << 10 | n << 5 | t); }
+static void str_u(int t, int n, int o) { E(0xb9000000 | (o / 4) << 10 | n << 5 | t); }
+static void ldrx_u(int t, int n, int o) { E(0xf9400000 | (o / 8) << 10 | n << 5 | t); }
+static void ldr_rr(int t, int n, int r, int ext) { E(0xb8600800 | r << 16 | ext << 13 | 1 << 12 | n << 5 | t); }
+static void str_rr(int t, int n, int r, int ext) { E(0xb8200800 | r << 16 | ext << 13 | 1 << 12 | n << 5 | t); }
+static void ldp_post(int t, int u, int n, int i) { E(0x28c00000 | ((i / 4) & 0x7f) << 15 | u << 10 | n << 5 | t); }
+static void op3(unsigned op, int d, int n, int r) { E(op | r << 16 | n << 5 | d); }
+static void addx_ext(int d, int n, int r, int ext) { E(0x8b200000 | r << 16 | ext << 13 | 2 << 10 | n << 5 | d); }
+static void movw(int d, int r) { E(0x2a0003e0 | r << 16 | d); }
+static void blr(int n) { E(0xd63f0000 | n << 5); }
+static void b_to(unsigned *t) { long o = t - cp; E(0x14000000 | (o & 0x3ffffff)); }
+static void cb_fix(unsigned *at, unsigned *to) { *at |= ((to - at) & 0x7ffff) << 5; }
+#define SXTW 6
+#define UXTW 2
+
+static void build_stubs(void)
+{
+	cp = code;
+	x_enter = cp;			/* int enter(long *S, void *code) */
+	E(0xa9bb7bfd);			/* stp x29, x30, [sp, #-80]! */
+	E(0x910003fd);			/* mov x29, sp */
+	E(0xa90153f3);			/* stp x19, x20, [sp, #16] */
+	E(0xa9025bf5);			/* stp x21, x22, [sp, #32] */
+	E(0xf9001bf7);			/* str x23, [sp, #48] */
+	E(0xa90467f8);			/* stp x24, x25, [sp, #64] */
+	E(0xaa0003f7);			/* mov x23, x0 */
+	ldrx_u(M, ST, 0);
+	ldrx_u(24, ST, 88); ldrx_u(25, ST, 96);	/* x24, x25: the stack limits, as addresses */
+	ldr_u(X9, ST, 8); addx_ext(SP, M, X9, UXTW);
+	ldr_u(X9, ST, 16); addx_ext(RP, M, X9, UXTW);
+	ldrx_u(TAB, ST, 24);
+	E(0xd61f0020);			/* br x1 */
+	x_exit = cp;			/* w0 = next vm address */
+	op3(0xcb000000, X9, SP, M); E(0xd342fd29); str_u(X9, ST, 8);	/* s = (x20 - x19) >> 2 */
+	op3(0xcb000000, X9, RP, M); E(0xd342fd29); str_u(X9, ST, 16);
+	E(0xa94153f3);			/* ldp x19, x20, [sp, #16] */
+	E(0xa9425bf5);			/* ldp x21, x22, [sp, #32] */
+	E(0xf9401bf7);			/* ldr x23, [sp, #48] */
+	E(0xa94467f8);			/* ldp x24, x25, [sp, #64] */
+	E(0xa8c57bfd);			/* ldp x29, x30, [sp], #80 */
+	E(0xd65f03c0);			/* ret */
+	{
+	unsigned *ovd = cp, *ovr;
+	li(W0, MW + 1); b_to(x_exit);	/* data stack overflow */
+	ovr = cp;
+	li(W0, MW + 2); b_to(x_exit);	/* return stack overflow */
+	x_disp = cp;			/* w0 = target: check the stacks, chain through tab[] or fall back to c */
+	E(0xeb18029f);			/* cmp x20, x24 */
+	E(0x54000003 | ((ovd - cp) & 0x7ffff) << 5);	/* b.lo data overflow */
+	E(0xeb1902bf);			/* cmp x21, x25 */
+	E(0x54000002 | ((ovr - cp) & 0x7ffff) << 5);	/* b.hs return overflow */
+	}
+	E(0x7144001f);			/* cmp w0, #MW */
+	E(0x54000002 | ((x_exit - cp) & 0x7ffff) << 5);	/* b.hs exit */
+	E(0xf8605ac9);			/* ldr x9, [x22, w0, uxtw #3] */
+	E(0xb4000009 | ((x_exit - cp) & 0x7ffff) << 5);	/* cbz x9, exit */
+	E(0xd61f0120);			/* br x9 */
+	x_first = cp;
+}
+
+static void flush(void)
+{
+	memset(tab, 0, sizeof tab);
+	memset(cov, 0, sizeof cov);
+	nbl = 0;
+	cp = x_first;
+	if (trace) fprintf(stderr, "jit: flushed\n");
+}
+
+static void jitwrite(int on)
+{
+#ifdef __APPLE__
+	pthread_jit_write_protect_np(!on);
+#else
+	(void)on;
+#endif
+}
+
+static void syncicache(unsigned *a, unsigned *b)
+{
+#ifdef __APPLE__
+	sys_icache_invalidate(a, (char *)b - (char *)a);
+#else
+	__builtin___clear_cache((char *)a, (char *)b);
+#endif
+}
+
+/* store hook for words that are covered by a translation */
+static int hook(int a, int v)
+{
+	int j, x, hit = 0;
+	if (m[a] == v) return 0;
+	m[a] = v;
+	for (j = 0; j < nbl; j++)
+		if (bl[j].a >= 0 && bl[j].a <= a && a < bl[j].b) {
+			tab[bl[j].a] = 0;
+			for (x = bl[j].a; x < bl[j].b; x++) cov[x] = 0;
+			if (trace) fprintf(stderr, "jit: dropped %d..%d\n", bl[j].a, bl[j].b - 1);
+			bl[j].a = -1;
+			hit = 1;
+		}
+	for (j = 0; j < nbl; j++)
+		if (bl[j].a >= 0) for (x = bl[j].a; x < bl[j].b; x++) cov[x] = 1;
+	return hit;
+}
+
+static void op(int i, int k)	/* everything except control flow */
+{
+	unsigned *a, *b, *c, *z;
+	switch (k) {
+	case 1: ldr_u(X9, SP, 0); ldr_rr(X9, M, X9, SXTW); str_u(X9, SP, 0); return;
+	case 2:	/* store: inline unless the target word is translated */
+		ldp_post(X9, X10, SP, 8);
+		E(0x7144013f);			/* cmp w9, #MW */
+		a = cp; E(0x54000002);		/* b.hs done */
+		ldrx_u(X11, ST, 32);
+		E(0x3869496b);			/* ldrb w11, [x11, w9, uxtw] */
+		b = cp; E(0x3500000b);		/* cbnz w11, slow */
+		str_rr(X10, M, X9, UXTW);
+		c = cp; E(0x14000000);		/* b done */
+		cb_fix(b, cp);			/* slow: hook(a, v) */
+		movw(W0, X9); movw(W1, X10); ldrx_u(X11, ST, 64); blr(X11);
+		z = cp; E(0x34000000);		/* cbz w0, done */
+		li(W0, i + 1); b_to(x_exit);	/* a translation died: resume at i+1 in c */
+		cb_fix(a, cp); cb_fix(z, cp);
+		*c |= (cp - c) & 0x3ffffff;
+		return;
+	case 3: ldr_u(X9, SP, 0); E(0x9100128a); ldr_rr(X9, X10, X9, SXTW); str_u(X9, SP, 0); return; /* add x10, x20, #4 */
+	case 4: E(0x91001294); return;	/* add x20, x20, #4 */
+	case 5: E(0x29402a89); E(0x2900268a); return;	/* ldp w9, w10, [x20]; stp w10, w9, [x20] */
+	case 10: ldrx_u(X11, ST, 40); blr(X11); E(0x13001c09); str_pre(X9, SP, -4); return; /* sxtb w9, w0 */
+	case 11:
+		ldrx_u(X9, ST, 56);
+		if (sizeof J == 1) E(0x39400129); else ldr_u(X9, X9, 0);	/* ldrb w9, [x9] */
+		str_pre(X9, SP, -4);
+		return;
+	case 12: ldr_post(W0, SP, 4); E(0x13001c00); ldrx_u(X11, ST, 48); blr(X11); return; /* sxtb w0, w0 */
+	}
+	ldr_post(X9, SP, 4);
+	ldr_u(X10, SP, 0);
+	switch (k) {
+	case 13: op3(0x0b000000, X10, X10, X9); break;
+	case 14: op3(0x4b000000, X10, X10, X9); break;
+	case 15: op3(0x1b007c00, X10, X10, X9); break;
+	case 16: op3(0x0a000000, X10, X10, X9); break;
+	case 17: op3(0x2a000000, X10, X10, X9); break;
+	case 18: op3(0x4a000000, X10, X10, X9); break;
+	case 19: op3(0x1ac02800, X10, X10, X9); break;
+	default: E(0x6b09015f); E(0x1a9fa7ea);	/* cmp w10, w9; cset w10, lt */
+	}
+	str_u(X10, SP, 0);
+}
+
+/* an enhancement, inlined: inputs from the data stack into w0..w15, the
+   optimized micro-ops, outputs back. x16 and x17 are scratch. */
+static void emit_enh(int s)
+{
+	Enh *e = &enh[s];
+	signed char *r = e->reg;
+	int i, j, delta;
+	if (!r) {	/* didn't fit in registers: x0 = data stack, w1 = slot, call the interpreter */
+		E(0xaa1403e0); li(W1, s); ldrx_u(X11, ST, 80); blr(X11); E(0xaa0003f4);
+		return;
+	}
+	for (j = 0; j < e->nin; j++) if (r[j] >= 0) ldr_u(r[j], SP, 4 * (e->nin - 1 - j));
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i];
+		int d = u->op == U_ST ? 0 : r[u->d], a = r[u->a], b = r[u->b], c = r[u->c];
+		switch (u->op) {
+		case U_LI: li(d, u->imm); break;
+		case U_ADD: op3(0x0b000000, d, a, b); break;
+		case U_SUB: op3(0x4b000000, d, a, b); break;
+		case U_MUL: op3(0x1b007c00, d, a, b); break;
+		case U_SDIV: op3(0x1ac00c00, d, a, b); break;
+		case U_UDIV: op3(0x1ac00800, d, a, b); break;
+		case U_SREM: op3(0x1ac00c00, 16, a, b); E(0x1b008000 | b << 16 | a << 10 | 16 << 5 | d); break;	/* msub */
+		case U_UREM: op3(0x1ac00800, 16, a, b); E(0x1b008000 | b << 16 | a << 10 | 16 << 5 | d); break;
+		case U_AND: op3(0x0a000000, d, a, b); break;
+		case U_OR: op3(0x2a000000, d, a, b); break;
+		case U_XOR: op3(0x4a000000, d, a, b); break;
+		case U_SHL: op3(0x1ac02000, d, a, b); break;
+		case U_SHR: op3(0x1ac02400, d, a, b); break;
+		case U_SAR: op3(0x1ac02800, d, a, b); break;
+		case U_NEG: E(0x4b0003e0 | a << 16 | d); break;
+		case U_NOT: E(0x2a2003e0 | a << 16 | d); break;
+		case U_LT: E(0x6b00001f | b << 16 | a << 5); E(0x1a9fa7e0 | d); break;	/* cmp; cset lt */
+		case U_LTU: E(0x6b00001f | b << 16 | a << 5); E(0x1a9f27e0 | d); break;	/* cset lo */
+		case U_EQ: E(0x6b00001f | b << 16 | a << 5); E(0x1a9f17e0 | d); break;
+		case U_NE: E(0x6b00001f | b << 16 | a << 5); E(0x1a9f07e0 | d); break;
+		case U_MIN: E(0x6b00001f | b << 16 | a << 5); E(0x1a800000 | b << 16 | 11 << 12 | a << 5 | d); break;
+		case U_MAX: E(0x6b00001f | b << 16 | a << 5); E(0x1a800000 | b << 16 | 12 << 12 | a << 5 | d); break;
+		case U_MINU: E(0x6b00001f | b << 16 | a << 5); E(0x1a800000 | b << 16 | 3 << 12 | a << 5 | d); break;
+		case U_MAXU: E(0x6b00001f | b << 16 | a << 5); E(0x1a800000 | b << 16 | 8 << 12 | a << 5 | d); break;
+		case U_MULHS: E(0x9b207c00 | b << 16 | a << 5 | 16); E(0xd360fc00 | 16 << 5 | d); break;	/* smull; lsr #32 */
+		case U_MULHU: E(0x9ba07c00 | b << 16 | a << 5 | 16); E(0xd360fc00 | 16 << 5 | d); break;
+		case U_CLZ: E(0x5ac01000 | a << 5 | d); break;
+		case U_ABS: E(0x7100001f | a << 5); E(0x5a800400 | a << 16 | 10 << 12 | a << 5 | d); break;	/* cmp #0; cneg */
+		case U_SEL: E(0x7100001f | a << 5); E(0x1a800000 | c << 16 | 1 << 12 | b << 5 | d); break;	/* csel ne */
+		case U_LD:	/* out of range reads 0, like the interpreter */
+			E(0x52800011); E(0x7144001f | a << 5); E(0x54000042); ldr_rr(17, M, a, UXTW); movw(d, 17);
+			break;
+		case U_ST: E(0x7144001f | a << 5); E(0x54000042); str_rr(b, M, a, UXTW); break;
+		}
+	}
+	delta = 4 * (e->nin - e->nout);
+	if (delta > 0) E(0x91000294 | delta << 10);
+	if (delta < 0) E(0xd1000294 | (-delta) << 10);
+	for (j = 0; j < e->nout; j++) str_u(r[e->out[j]], SP, 4 * (e->nout - 1 - j));
+}
+static int inst_hook(int d) { return install(d); }
+static long xrun(long sp, int slot) { return (long)xexec(&enh[slot], (int *)sp); }
+
+static void *translate(int p)
+{
+	unsigned *start;
+	int i = p, n = 0, w, k, t;
+	if (cp - code > CODEW - 65536 || nbl >= MAXB) flush();
+	start = cp;
+	for (;;) {
+		if (i >= MW) { E(0x12800000); b_to(x_exit); break; }	/* movn w0, #0: halt */
+		if (n++ >= BLKW) { li(W0, i); b_to(x_disp); break; }
+		w = m[i];
+		cov[i] = 1;
+		if (w & 1 && i + 1 < MW && !(m[i + 1] & 1) && (k = m[i + 1] / 2) >= 6 && k <= 8) {
+			t = (w - 1) / 2;	/* literal + call/jmp/jz with a known target */
+			cov[i + 1] = 1;
+			if (k == 8) {
+				unsigned *a;
+				ldr_post(X10, SP, 4);
+				a = cp; E(0x3500000a);	/* cbnz w10, fallthrough */
+				li(W0, t); b_to(x_disp);
+				cb_fix(a, cp);
+				i += 2;
+				continue;
+			}
+			li(X10, i + 2);
+			if (k == 6) str_post(X10, RP, 4); else str_u(X10, RP, 0);
+			li(W0, t); b_to(x_disp);
+			i += 2;
+			break;
+		}
+		if (w & 1) { li(X9, (w - 1) / 2); str_pre(X9, SP, -4); i++; continue; }
+		k = w / 2;
+		if (k == 0) { E(0x12800000); b_to(x_exit); i++; break; }
+		if (k < 0 || k == 6 || k == 7) {
+			ldr_post(W0, SP, 4);
+			li(X10, i + 1);
+			if (k == 6) str_post(X10, RP, 4); else str_u(X10, RP, 0);
+			if (k < 0) { li(X11, 7 - k); addx_ext(RP, RP, X11, SXTW); }
+			b_to(x_disp);
+			i++;
+			break;
+		}
+		if (k == 8) {	/* jz: taken leaves, not taken keeps going */
+			ldp_post(X9, X10, SP, 8);
+			E(0x3500006a);		/* cbnz w10, +3 */
+			movw(W0, X9);
+			b_to(x_disp);
+			i++;
+			continue;
+		}
+		if (k == 9) { ldr_pre(W0, RP, -4); b_to(x_disp); i++; break; }
+		if (k == 21) {	/* install: call into c, then return to it so it can flush */
+			ldr_u(W0, SP, 0); ldrx_u(X11, ST, 72); blr(X11); str_u(W0, SP, 0);
+			li(W0, i + 1); b_to(x_exit); i++; break;
+		}
+		if (k >= XOP0 && k < XOP0 + NENH && enh[k - XOP0].live) { emit_enh(k - XOP0); i++; continue; }
+		if (k > 20) { E(0x12800000); b_to(x_exit); i++; break; }	/* not wired: halt */
+		op(i, k);
+		i++;
+	}
+	bl[nbl].a = p;
+	bl[nbl++].b = i;
+	tab[p] = start;
+	syncicache(start, cp);
+	if (trace) fprintf(stderr, "jit: %d..%d -> %ld bytes\n", p, i - 1, (long)((char *)cp - (char *)start));
+	return start;
+}
+
+#else
+/* portable path for hosts without the arm64 jit: a plain interpreter with
+   the same semantics (shift counts wrap at 32, stores outside memory are
+   ignored, loads outside memory read 0, leaving memory halts). */
+#ifdef ZYLLVM
+/* ---- llvm backend ----
+   a tiered jit for hosts the arm64 backend doesn't cover. the interpreter
+   counts how often each block start is reached; a hot block is translated to
+   llvm ir (same block rules as the arm64 jit: it ends at call, jump, ret or
+   halt, and keeps going past a jz), optimized at O2 and compiled with orc.
+   enhancements are inlined as ir. stores into compiled words drop the blocks
+   that cover them, so self-modifying code still works. */
+#include <llvm-c/Core.h>
+#include <llvm-c/Error.h>
+#include <llvm-c/LLJIT.h>
+#include <llvm-c/Orc.h>
+#include <llvm-c/Target.h>
+#include <llvm-c/Transforms/PassBuilder.h>
+static int HOT = 5000;		/* runs before a block gets compiled: ZYHOT */
+static const char *lpasses = "default<O2>";	/* ZYPASSES */
+#define LMAXB 65536
+typedef int (*Blk)(int *mem, int *regs);
+static Blk lt[MW];			/* address -> compiled block */
+static unsigned short hot[MW];
+static unsigned char lcov[MW];		/* 1 if a compiled block covers the word */
+static struct { int a, b; } lbl[LMAXB];
+static int nlbl, llvm_ok, nblocks;
+static LLVMOrcLLJITRef jit;
+static LLVMOrcThreadSafeContextRef tsc;
+static LLVMContextRef ctx;
+static LLVMTypeRef i8t, i32t, i64t, ptrt, i1t;
+static LLVMBuilderRef bd;
+static LLVMValueRef fn_, vm_, vregs, vs, vr;	/* function, memory, regs, s and r slots */
+static LLVMModuleRef mod_;
+
+static void ldrop_all(void)
+{
+	memset(lt, 0, sizeof lt); memset(lcov, 0, sizeof lcov); memset(hot, 0, sizeof hot); nlbl = 0;
+	if (trace) fprintf(stderr, "llvm: dropped every block\n");
+}
+/* a store to a word some block covers: write it, drop those blocks */
+static int lhook(int a, int v)
+{
+	int j, x, hit = 0;
+	if (m[a] == v) return 0;
+	m[a] = v;
+	for (j = 0; j < nlbl; j++)
+		if (lbl[j].a >= 0 && lbl[j].a <= a && a < lbl[j].b) {
+			lt[lbl[j].a] = 0; hot[lbl[j].a] = 0;
+			if (trace) fprintf(stderr, "llvm: dropped %d..%d\n", lbl[j].a, lbl[j].b - 1);
+			lbl[j].a = -1; hit = 1;
+		}
+	if (hit) {
+		memset(lcov, 0, sizeof lcov);
+		for (j = 0; j < nlbl; j++) if (lbl[j].a >= 0) for (x = lbl[j].a; x < lbl[j].b; x++) lcov[x] = 1;
+	}
+	return hit;
+}
+static int linstall(int d) { return install(d); }
+
+static LLVMValueRef K32(int v) { return LLVMConstInt(i32t, (unsigned)v, 0); }
+static LLVMValueRef cptr(void *p) { return LLVMConstIntToPtr(LLVMConstInt(i64t, (unsigned long long)(size_t)p, 0), ptrt); }
+static LLVMValueRef mslot(LLVMValueRef idx) { return LLVMBuildGEP2(bd, i32t, vm_, &idx, 1, ""); }
+static LLVMValueRef ld(LLVMValueRef idx) { return LLVMBuildLoad2(bd, i32t, mslot(idx), ""); }
+static void st(LLVMValueRef idx, LLVMValueRef v) { LLVMBuildStore(bd, v, mslot(idx)); }
+static LLVMValueRef gets(void) { return LLVMBuildLoad2(bd, i32t, vs, ""); }
+static void sets(LLVMValueRef v) { LLVMBuildStore(bd, v, vs); }
+static LLVMValueRef add(LLVMValueRef a, int k) { return LLVMBuildAdd(bd, a, K32(k), ""); }
+/* a load that reads 0 outside memory */
+static LLVMValueRef safeld(LLVMValueRef a)
+{
+	LLVMValueRef in = LLVMBuildICmp(bd, LLVMIntULT, a, K32(MW), "");
+	LLVMValueRef v = ld(LLVMBuildSelect(bd, in, a, K32(0), ""));
+	return LLVMBuildSelect(bd, in, v, K32(0), "");
+}
+static void push(LLVMValueRef v) { LLVMValueRef s = add(gets(), -1); sets(s); st(s, v); }
+/* leave the block: write s and r back, return the next vm address */
+static void leave(LLVMValueRef next)
+{
+	LLVMValueRef r0 = K32(0), r1 = K32(1);
+	LLVMBuildStore(bd, gets(), LLVMBuildGEP2(bd, i32t, vregs, &r0, 1, ""));
+	LLVMBuildStore(bd, LLVMBuildLoad2(bd, i32t, vr, ""), LLVMBuildGEP2(bd, i32t, vregs, &r1, 1, ""));
+	LLVMBuildRet(bd, next);
+}
+static LLVMBasicBlockRef newbb(void) { return LLVMAppendBasicBlockInContext(ctx, fn_, ""); }
+static LLVMValueRef callp(void *f, LLVMTypeRef ret, LLVMTypeRef *at, int n, LLVMValueRef *args)
+{
+	LLVMTypeRef ft = LLVMFunctionType(ret, at, (unsigned)n, 0);
+	return LLVMBuildCall2(bd, ft, cptr(f), args, (unsigned)n, "");
+}
+/* an enhancement as ir: the same semantics as ev() */
+static void ir_enh(Enh *e)
+{
+	LLVMValueRef *v = calloc(e->nv + 1, sizeof *v), s = gets(), z = K32(0), q, d, t, c1, c2;
+	int i, j;
+	LLVMTypeRef i64 = i64t;
+	for (j = 0; j < e->nin; j++) v[j] = ld(add(s, e->nin - 1 - j));
+	for (i = 0; i < e->n; i++) {
+		Uop *u = &e->u[i];
+		LLVMValueRef a = u->op == U_LI ? 0 : v[u->a], b = uarity[u->op] > 1 || u->op == U_ST ? v[u->b] : 0, c = uarity[u->op] > 2 ? v[u->c] : 0, r = 0;
+		switch (u->op) {
+		case U_LI: r = K32(u->imm); break;
+		case U_ADD: r = LLVMBuildAdd(bd, a, b, ""); break;
+		case U_SUB: r = LLVMBuildSub(bd, a, b, ""); break;
+		case U_MUL: r = LLVMBuildMul(bd, a, b, ""); break;
+		case U_SDIV: case U_SREM:	/* /0 and INT_MIN/-1 are defined, like the cpu */
+			c1 = LLVMBuildICmp(bd, LLVMIntEQ, b, z, "");
+			c2 = LLVMBuildAnd(bd, LLVMBuildICmp(bd, LLVMIntEQ, a, K32((int)0x80000000), ""), LLVMBuildICmp(bd, LLVMIntEQ, b, K32(-1), ""), "");
+			d = LLVMBuildSelect(bd, LLVMBuildOr(bd, c1, c2, ""), K32(1), b, "");
+			if (u->op == U_SDIV) { q = LLVMBuildSDiv(bd, a, d, ""); r = LLVMBuildSelect(bd, c1, z, q, ""); }
+			else { q = LLVMBuildSRem(bd, a, d, ""); r = LLVMBuildSelect(bd, c1, a, LLVMBuildSelect(bd, c2, z, q, ""), ""); }
+			break;
+		case U_UDIV: case U_UREM:
+			c1 = LLVMBuildICmp(bd, LLVMIntEQ, b, z, "");
+			d = LLVMBuildSelect(bd, c1, K32(1), b, "");
+			if (u->op == U_UDIV) r = LLVMBuildSelect(bd, c1, z, LLVMBuildUDiv(bd, a, d, ""), "");
+			else r = LLVMBuildSelect(bd, c1, a, LLVMBuildURem(bd, a, d, ""), "");
+			break;
+		case U_AND: r = LLVMBuildAnd(bd, a, b, ""); break;
+		case U_OR: r = LLVMBuildOr(bd, a, b, ""); break;
+		case U_XOR: r = LLVMBuildXor(bd, a, b, ""); break;
+		case U_SHL: r = LLVMBuildShl(bd, a, LLVMBuildAnd(bd, b, K32(31), ""), ""); break;
+		case U_SHR: r = LLVMBuildLShr(bd, a, LLVMBuildAnd(bd, b, K32(31), ""), ""); break;
+		case U_SAR: r = LLVMBuildAShr(bd, a, LLVMBuildAnd(bd, b, K32(31), ""), ""); break;
+		case U_NEG: r = LLVMBuildSub(bd, z, a, ""); break;
+		case U_NOT: r = LLVMBuildNot(bd, a, ""); break;
+		case U_LT: r = LLVMBuildZExt(bd, LLVMBuildICmp(bd, LLVMIntSLT, a, b, ""), i32t, ""); break;
+		case U_LTU: r = LLVMBuildZExt(bd, LLVMBuildICmp(bd, LLVMIntULT, a, b, ""), i32t, ""); break;
+		case U_EQ: r = LLVMBuildZExt(bd, LLVMBuildICmp(bd, LLVMIntEQ, a, b, ""), i32t, ""); break;
+		case U_NE: r = LLVMBuildZExt(bd, LLVMBuildICmp(bd, LLVMIntNE, a, b, ""), i32t, ""); break;
+		case U_MIN: r = LLVMBuildSelect(bd, LLVMBuildICmp(bd, LLVMIntSLT, a, b, ""), a, b, ""); break;
+		case U_MAX: r = LLVMBuildSelect(bd, LLVMBuildICmp(bd, LLVMIntSGT, a, b, ""), a, b, ""); break;
+		case U_MINU: r = LLVMBuildSelect(bd, LLVMBuildICmp(bd, LLVMIntULT, a, b, ""), a, b, ""); break;
+		case U_MAXU: r = LLVMBuildSelect(bd, LLVMBuildICmp(bd, LLVMIntUGT, a, b, ""), a, b, ""); break;
+		case U_MULHS: case U_MULHU: {
+			LLVMValueRef x = u->op == U_MULHS ? LLVMBuildSExt(bd, a, i64, "") : LLVMBuildZExt(bd, a, i64, "");
+			LLVMValueRef y = u->op == U_MULHS ? LLVMBuildSExt(bd, b, i64, "") : LLVMBuildZExt(bd, b, i64, "");
+			r = LLVMBuildTrunc(bd, LLVMBuildLShr(bd, LLVMBuildMul(bd, x, y, ""), LLVMConstInt(i64, 32, 0), ""), i32t, "");
+			break; }
+		case U_CLZ: {
+			unsigned id = LLVMLookupIntrinsicID("llvm.ctlz", 9);
+			LLVMValueRef f = LLVMGetIntrinsicDeclaration(mod_, id, &i32t, 1), args[2];
+			args[0] = a; args[1] = LLVMConstInt(i1t, 0, 0);
+			r = LLVMBuildCall2(bd, LLVMIntrinsicGetType(ctx, id, &i32t, 1), f, args, 2, "");
+			break; }
+		case U_ABS: t = LLVMBuildICmp(bd, LLVMIntSLT, a, z, ""); r = LLVMBuildSelect(bd, t, LLVMBuildSub(bd, z, a, ""), a, ""); break;
+		case U_SEL: r = LLVMBuildSelect(bd, LLVMBuildICmp(bd, LLVMIntNE, a, z, ""), b, c, ""); break;
+		case U_LD: r = safeld(a); break;
+		case U_ST: {
+			LLVMBasicBlockRef yes = newbb(), done = newbb();
+			LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntULT, a, K32(MW), ""), yes, done);
+			LLVMPositionBuilderAtEnd(bd, yes); st(a, b); LLVMBuildBr(bd, done);
+			LLVMPositionBuilderAtEnd(bd, done);
+			break; }
+		}
+		if (u->op != U_ST) v[u->d] = r;
+	}
+	s = add(s, e->nin - e->nout); sets(s);
+	for (j = 0; j < e->nout; j++) st(add(s, e->nout - 1 - j), v[e->out[j]]);
+	free(v);
+}
+static void llvm_init(void)
+{
+	LLVMErrorRef err;
+	if (getenv("ZYHOT")) HOT = atoi(getenv("ZYHOT"));
+	if (HOT < 1) HOT = 1;
+	if (HOT > 65000) HOT = 65000;
+	if (getenv("ZYPASSES")) lpasses = getenv("ZYPASSES");
+	LLVMInitializeNativeTarget(); LLVMInitializeNativeAsmPrinter();
+	if ((err = LLVMOrcCreateLLJIT(&jit, 0))) { char *msg = LLVMGetErrorMessage(err); fprintf(stderr, "llvm: %s\n", msg); LLVMDisposeErrorMessage(msg); return; }
+	tsc = LLVMOrcCreateNewThreadSafeContext();
+	ctx = LLVMOrcThreadSafeContextGetContext(tsc);
+	i1t = LLVMInt1TypeInContext(ctx); i8t = LLVMInt8TypeInContext(ctx); i32t = LLVMInt32TypeInContext(ctx);
+	i64t = LLVMInt64TypeInContext(ctx); ptrt = LLVMPointerTypeInContext(ctx, 0);
+	bd = LLVMCreateBuilderInContext(ctx);
+	llvm_ok = 1;
+}
+/* compile the block at p; 0 if it couldn't be */
+static Blk lcompile(int p)
+{
+	char name[32]; LLVMTypeRef pt[2], ft; LLVMValueRef s, a, b, v, r, args[2]; LLVMTypeRef at[2];
+	LLVMOrcExecutorAddress addr; LLVMErrorRef err; LLVMPassBuilderOptionsRef po;
+	int i = p, n = 0, w, k, t, done = 0;
+	if (!llvm_ok || nlbl >= LMAXB) return 0;
+	sprintf(name, "b%d_%d", p, nblocks++);
+	mod_ = LLVMModuleCreateWithNameInContext(name, ctx);
+	pt[0] = ptrt; pt[1] = ptrt;
+	ft = LLVMFunctionType(i32t, pt, 2, 0);
+	fn_ = LLVMAddFunction(mod_, name, ft);
+	vm_ = LLVMGetParam(fn_, 0); vregs = LLVMGetParam(fn_, 1);
+	LLVMPositionBuilderAtEnd(bd, newbb());
+	vs = LLVMBuildAlloca(bd, i32t, "s"); vr = LLVMBuildAlloca(bd, i32t, "r");
+	{ LLVMValueRef r0 = K32(0), r1 = K32(1);
+	  sets(LLVMBuildLoad2(bd, i32t, LLVMBuildGEP2(bd, i32t, vregs, &r0, 1, ""), ""));
+	  LLVMBuildStore(bd, LLVMBuildLoad2(bd, i32t, LLVMBuildGEP2(bd, i32t, vregs, &r1, 1, ""), ""), vr); }
+	while (!done) {
+		if (i >= MW) { leave(K32(MW)); break; }
+		if (n++ >= 1024) { leave(K32(i)); break; }
+		w = m[i];
+		lcov[i] = 1;
+		if (w & 1) {
+			/* a literal followed by call, jump or jz: a known target */
+			if (i + 1 < MW && !(m[i + 1] & 1) && (k = m[i + 1] / 2) >= 6 && k <= 8) {
+				t = w >> 1; lcov[i + 1] = 1;
+				if (k == 8) {
+					LLVMBasicBlockRef tk = newbb(), go = newbb();
+					s = gets(); a = ld(s); sets(add(s, 1));
+					LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntEQ, a, K32(0), ""), tk, go);
+					LLVMPositionBuilderAtEnd(bd, tk); leave(K32(t));
+					LLVMPositionBuilderAtEnd(bd, go);
+					i += 2; continue;
+				}
+				if (k == 6) { r = LLVMBuildLoad2(bd, i32t, vr, ""); st(r, K32(i + 2)); LLVMBuildStore(bd, add(r, 1), vr); }
+				leave(K32(t)); i += 2; break;
+			}
+			push(K32(w >> 1)); i++; continue;
+		}
+		k = w / 2;
+		s = gets();
+		switch (k) {
+		case 0: leave(K32(MW)); done = 1; break;
+		case 1: st(s, safeld(ld(s))); break;
+		case 2: {
+			LLVMBasicBlockRef in = newbb(), cv = newbb(), plain = newbb(), out = newbb(), quit = newbb();
+			a = ld(s); b = ld(add(s, 1)); sets(add(s, 2));
+			LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntULT, a, K32(MW), ""), in, out);
+			LLVMPositionBuilderAtEnd(bd, in);
+			v = LLVMBuildLoad2(bd, i8t, LLVMBuildGEP2(bd, i8t, cptr(lcov), &a, 1, ""), "");
+			LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntNE, v, LLVMConstInt(i8t, 0, 0), ""), cv, plain);
+			LLVMPositionBuilderAtEnd(bd, plain); st(a, b); LLVMBuildBr(bd, out);
+			LLVMPositionBuilderAtEnd(bd, cv);
+			at[0] = i32t; at[1] = i32t; args[0] = a; args[1] = b;
+			v = callp((void *)lhook, i32t, at, 2, args);
+			LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntNE, v, K32(0), ""), quit, out);
+			LLVMPositionBuilderAtEnd(bd, quit); leave(K32(i + 1));	/* a block died: back to the loop */
+			LLVMPositionBuilderAtEnd(bd, out);
+			break; }
+		case 3: a = ld(s); st(s, safeld(LLVMBuildAdd(bd, add(s, 1), a, ""))); break;
+		case 4: sets(add(s, 1)); break;
+		case 5: a = ld(s); b = ld(add(s, 1)); st(s, b); st(add(s, 1), a); break;
+		case 6: case 7:
+			a = ld(s); sets(add(s, 1));
+			if (k == 6) { r = LLVMBuildLoad2(bd, i32t, vr, ""); st(r, K32(i + 1)); LLVMBuildStore(bd, add(r, 1), vr); }
+			leave(a); done = 1; break;
+		case 8: {
+			LLVMBasicBlockRef tk = newbb(), go = newbb();
+			a = ld(s); b = ld(add(s, 1)); sets(add(s, 2));
+			LLVMBuildCondBr(bd, LLVMBuildICmp(bd, LLVMIntEQ, b, K32(0), ""), tk, go);
+			LLVMPositionBuilderAtEnd(bd, tk); leave(a);
+			LLVMPositionBuilderAtEnd(bd, go);
+			break; }
+		case 9:
+			r = add(LLVMBuildLoad2(bd, i32t, vr, ""), -1); LLVMBuildStore(bd, r, vr);
+			leave(ld(r)); done = 1; break;
+		case 10: v = callp((void *)Q, i8t, 0, 0, 0); push(LLVMBuildSExt(bd, v, i32t, "")); break;
+		case 11:
+			if (sizeof J == 1) push(LLVMBuildZExt(bd, LLVMBuildLoad2(bd, i8t, cptr(&J), ""), i32t, ""));
+			else push(LLVMBuildLoad2(bd, i32t, cptr(&J), ""));
+			break;
+		case 12: at[0] = i8t; args[0] = LLVMBuildTrunc(bd, ld(s), i8t, ""); callp((void *)G, LLVMVoidTypeInContext(ctx), at, 1, args); sets(add(s, 1)); break;
+		case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20:
+			a = ld(s); b = ld(add(s, 1)); s = add(s, 1); sets(s);
+			switch (k) {
+			case 13: v = LLVMBuildAdd(bd, b, a, ""); break;
+			case 14: v = LLVMBuildSub(bd, b, a, ""); break;
+			case 15: v = LLVMBuildMul(bd, b, a, ""); break;
+			case 16: v = LLVMBuildAnd(bd, b, a, ""); break;
+			case 17: v = LLVMBuildOr(bd, b, a, ""); break;
+			case 18: v = LLVMBuildXor(bd, b, a, ""); break;
+			case 19: v = LLVMBuildAShr(bd, b, LLVMBuildAnd(bd, a, K32(31), ""), ""); break;
+			default: v = LLVMBuildZExt(bd, LLVMBuildICmp(bd, LLVMIntSLT, b, a, ""), i32t, "");
+			}
+			st(s, v); break;
+		case 21:	/* install: then back to the loop, which drops every block */
+			at[0] = i32t; args[0] = ld(s);
+			st(s, callp((void *)linstall, i32t, at, 1, args));
+			leave(K32(i + 1)); done = 1; break;
+		default:
+			if (k >= XOP0 && k < XOP0 + NENH && enh[k - XOP0].live) { ir_enh(&enh[k - XOP0]); break; }
+			leave(K32(MW)); done = 1;	/* not wired: halt */
+		}
+		i++;
+	}
+	lbl[nlbl].a = p; lbl[nlbl++].b = i;
+	po = LLVMCreatePassBuilderOptions();
+	if ((err = LLVMRunPasses(mod_, lpasses, 0, po))) { LLVMConsumeError(err); }
+	LLVMDisposePassBuilderOptions(po);
+	if ((err = LLVMOrcLLJITAddLLVMIRModule(jit, LLVMOrcLLJITGetMainJITDylib(jit), LLVMOrcCreateNewThreadSafeModule(mod_, tsc)))) {
+		char *msg = LLVMGetErrorMessage(err); fprintf(stderr, "llvm: %s\n", msg); LLVMDisposeErrorMessage(msg); return 0;
+	}
+	if ((err = LLVMOrcLLJITLookup(jit, &addr, name))) { char *msg = LLVMGetErrorMessage(err); fprintf(stderr, "llvm: %s\n", msg); LLVMDisposeErrorMessage(msg); return 0; }
+	if (trace) fprintf(stderr, "llvm: %d..%d compiled\n", p, i - 1);
+	return (Blk)(size_t)addr;
+}
+#endif
+#define LD(x) ((unsigned)(x) < MW ? m[x] : 0)
+static int run(int p)
+{
+	int s = DS0, r = RS0, w, a, b, xfer = 1;
+	unsigned long long steps = 0;
+#ifdef ZYLLVM
+	int regs[2];
+	if (!getenv("ZYNOLLVM")) llvm_init();
+#endif
+	while ((unsigned)p < MW) {
+		if (xfer && (s < DSLIM || r > RSLIM)) { p = s < DSLIM ? MW + 1 : MW + 2; break; }
+#ifdef ZYLLVM
+		if (xfer && llvm_ok) {	/* at a block start: run it compiled, or count it */
+			xfer = 0;
+			if (!lt[p] && hot[p] < 65535 && ++hot[p] == HOT && !(lt[p] = lcompile(p))) hot[p] = 65535;
+			if (lt[p]) {
+				regs[0] = s; regs[1] = r;
+				p = lt[p](m, regs);
+				s = regs[0]; r = regs[1];
+				if (need_flush) { need_flush = 0; ldrop_all(); }
+				xfer = 1;
+				continue;
+			}
+		}
+#endif
+		w = m[p++];
+		steps++;
+		if (w & 1) { m[--s] = w >> 1; continue; }
+		a = m[s]; b = m[s + 1];
+		switch (w / 2) {
+		case 1: m[s] = LD(a); break;
+		case 2:
+			if ((unsigned)a < MW) {
+#ifdef ZYLLVM
+				if (lcov[a]) lhook(a, b); else
+#endif
+				m[a] = b;
+			}
+			s += 2; break;
+		case 3: m[s] = LD(s + 1 + a); break;
+		case 4: s++; break;
+		case 5: m[s] = b; m[s + 1] = a; break;
+		case 6: m[r++] = p; p = a; s++; xfer = 1; break;
+		case 7: p = a; s++; xfer = 1; break;
+		case 8: if (!b) { p = a; xfer = 1; } s += 2; break;
+		case 9: p = m[--r]; xfer = 1; break;
+		case 10: m[--s] = (signed char)Q(); break;
+		case 11: m[--s] = J; break;
+		case 12: G((char)a); s++; break;
+		case 13: m[++s] = b + a; break;
+		case 14: m[++s] = (int)((unsigned)b - (unsigned)a); break;
+		case 15: m[++s] = (int)((unsigned)b * (unsigned)a); break;
+		case 16: m[++s] = b & a; break;
+		case 17: m[++s] = b | a; break;
+		case 18: m[++s] = b ^ a; break;
+		case 19: m[++s] = b >> (a & 31); break;
+		case 20: m[++s] = b < a; break;
+		case 21:
+			m[s] = install(a);
+#ifdef ZYLLVM
+			if (need_flush) { need_flush = 0; ldrop_all(); }
+#endif
+			break;
+		default:
+			if (w / 2 >= XOP0 && w / 2 < XOP0 + NENH && enh[w / 2 - XOP0].live) s = (int)(xexec(&enh[w / 2 - XOP0], m + s) - m);
+			else p = MW;	/* halt: unwired opcodes and the reserved negative ones */
+		}
+	}
+	if (trace) fprintf(stderr, "interp: %llu steps\n", steps);
+	return stopped(p);
+}
+#endif
+
+int main(void)
+{
+	trace = getenv("ZYTRACE") != 0;
+	memcpy(m + GORG, genome, sizeof genome);
+#ifdef ZYJIT
+	{
+	int p = GORG;
+	union { unsigned *u; int (*f)(long *, void *); } enter;
+#ifdef __APPLE__
+	code = mmap(0, CODEW * 4, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON | MAP_JIT, -1, 0);
+#else
+	code = mmap(0, CODEW * 4, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+#endif
+	if (code == MAP_FAILED) { perror("mmap"); return 1; }
+	jitwrite(1);
+	build_stubs();
+	jitwrite(0);
+	syncicache(code, cp);
+	S[0] = (long)m; S[1] = DS0; S[2] = RS0; S[3] = (long)tab; S[4] = (long)cov;
+	S[5] = (long)Q; S[6] = (long)G; S[7] = (long)&J; S[8] = (long)hook;
+	S[9] = (long)inst_hook; S[10] = (long)xrun;
+	S[11] = (long)(m + DSLIM); S[12] = (long)(m + RSLIM);
+	enter.u = x_enter;
+	while ((unsigned)p < MW) {
+		void *c = tab[p];
+		if (!c) { jitwrite(1); c = translate(p); jitwrite(0); }
+		p = enter.f(S, c);
+		if (need_flush) { need_flush = 0; jitwrite(1); flush(); jitwrite(0); }
+	}
+	return stopped(p);
+	}
+#else
+	return run(GORG);
+#endif
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/examples/echo.zc b/docs/history/13-gap-fixes/code/examples/echo.zc
new file mode 100644
index 0000000..01f28b0
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/echo.zc
@@ -0,0 +1,2 @@
+// everything after the backtick is left unread, for the program itself
+fn main() { while (!eof()) putc(getc()); return 0; }
diff --git a/docs/history/13-gap-fixes/code/examples/fact.zc b/docs/history/13-gap-fixes/code/examples/fact.zc
new file mode 100644
index 0000000..2a218b2
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/fact.zc
@@ -0,0 +1,4 @@
+fn fact(n) { if (n < 2) return 1; return n * fact(n - 1); }
+// prints in binary, like the old asm example
+fn bin(n) { if (n > 1) bin(n >> 1); putc('0' + (n & 1)); return 0; }
+fn main() { bin(fact(10)); putc(10); putn(fact(10)); putc(10); return 0; }
diff --git a/docs/history/13-gap-fixes/code/examples/hello.zc b/docs/history/13-gap-fixes/code/examples/hello.zc
new file mode 100644
index 0000000..f36a810
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/hello.zc
@@ -0,0 +1 @@
+fn main() { puts("hello, world!\n"); return 0; }
diff --git a/docs/history/13-gap-fixes/code/examples/lists.zc b/docs/history/13-gap-fixes/code/examples/lists.zc
new file mode 100644
index 0000000..6ac276e
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/lists.zc
@@ -0,0 +1,35 @@
+// ownership in practice: a list owns its boxes. nothing here calls free;
+// everything is released at the end of the block that owns it.
+fn box(v) -> .u { let b = new(1); b[0] = v; return u*b; }
+fn mklist(cap) -> .u { let l = new(cap + 1); l[0] = 0; return u*l; }
+// item m*arrives (it was given down), and goes d*on into the borrowed list
+fn push(.m l, .d item) { l[l[0] + 1] = d*item; l[0] = l[0] + 1; return 0; }
+fn show(.m l)
+{
+	let i = 1;
+	putc('[');
+	while (i <= l[0]) { if (i > 1) putc(' '); putn(l[i][0]); i++; }
+	putc(']');
+	return 0;
+}
+fn squares(n) -> .u
+{
+	let l = mklist(n), i = 0;
+	while (i < n) {
+		let b = box(i * i);
+		push(l, d*b);
+		i++;
+	}
+	return u*l;
+}
+fn main()
+{
+	let before = live_objects();
+	{
+		let l = squares(6);
+		show(l); putc(10);
+		puts("live: "); putn(live_objects() - before); putc(10);
+	}
+	puts("after the block: "); putn(live_objects() - before); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/examples/repl.zc b/docs/history/13-gap-fixes/code/examples/repl.zc
new file mode 100644
index 0000000..b7b81b8
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/repl.zc
@@ -0,0 +1,27 @@
+// a repl on the resident compiler: each backtick-separated chunk of input is
+// compiled as a function body and run. definitions (fn ...) can be loaded too:
+// a chunk that starts with "fn" goes through load instead of eval.
+let buf[4000];
+fn readchunk()
+{
+	let n = 0, c;
+	while (!eof()) {
+		c = getc();
+		if (c == 96) break;
+		if (n < 3999) { buf[n] = c; n++; }
+	}
+	buf[n] = 0;
+	return n;
+}
+fn main()
+{
+	let q, i;
+	while (!eof()) {
+		readchunk();
+		q = tokens(buf);
+		if (q[0] && q[1] == T_ID && q[2] == intern("fn")) load(q);
+		else eval(q);
+		free(d*q);
+	}
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/examples/selfpatch.zc b/docs/history/13-gap-fixes/code/examples/selfpatch.zc
new file mode 100644
index 0000000..074ccec
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/selfpatch.zc
@@ -0,0 +1,17 @@
+// code is data: find the literal 'A' inside f's compiled words and rewrite it.
+// on the jit the store lands on translated code, which gets dropped and
+// retranslated on the next call.
+fn f() { putc('A'); return 0; }
+fn litw(v) { return v + v + 1; }	// how the vm encodes a literal push
+fn main()
+{
+	let p = f;
+	f();
+	while (*p != litw('A')) p++;
+	*p = litw('B');
+	f();
+	*p = litw('C');
+	f();
+	putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/examples/typed.zc b/docs/history/13-gap-fixes/code/examples/typed.zc
new file mode 100644
index 0000000..d91fe6a
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/typed.zc
@@ -0,0 +1,47 @@
+// types: structs, a generic container, and looking at it all through reflection
+typecheck on;
+struct point { int x, y; };
+struct vec<T> { int len, cap; *T items; };
+
+fn mkvec<T>(int cap) -> *vec<T>.u
+{
+	*vec<T> v = new(vec<T>);
+	v.cap = cap;
+	v.items = new(T, cap);
+	return u*v;
+}
+// x is given away (.d): the vector's memory holds it from now on, and the
+// collector looks after it
+fn push<T>(*vec<T> v, T.d x) -> bool
+{
+	if (v.len == v.cap) { free(d*x); return 0; }
+	v.items[v.len] = d*x;
+	v.len++;
+	return 1;
+}
+fn show(word t)
+{
+	let i = 0;
+	tprint(t); puts(" is "); putn(tsize(t)); puts(" words: ");
+	while (i < tnfields(t)) { if (i) puts(", "); puts(tfname(t, i)); puts(" "); tprint(tftype(t, i)); i++; }
+	putc(10);
+	return 0;
+}
+fn main() -> int
+{
+	*vec<*point> v = mkvec<*point>(4);
+	int i = 0;
+	while (i < 3) {
+		*point p = new(point);
+		p.x = i; p.y = i * i;
+		push(v, d*p);
+		i++;
+	}
+	puts("last: "); putn(v.items[2].y); putc(10);
+	show(typeof(point));
+	show(typeof(*v));
+	puts("push is "); tprint(sigof(push)); putc(10);
+	// generic code is compiled once, so what mkvec stamped is vec<T>
+	puts("the heap says v is a "); tprint(typeof_obj(v)); puts(", and v.items[0] is a "); tprint(typeof_obj(v.items[0])); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/examples/wiring.zc b/docs/history/13-gap-fixes/code/examples/wiring.zc
new file mode 100644
index 0000000..ed30935
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/examples/wiring.zc
@@ -0,0 +1,19 @@
+// virtual enhancements: custom opcodes wired into the cpu while compiling.
+// the recipes run through the core's optimizer; the jit inlines the result.
+enhance popcount(x) micro
+	"r1 = shr x 1; r1 = and r1 0x55555555; x = sub x r1"
+	"; r1 = shr x 2; r1 = and r1 0x33333333; x = and x 0x33333333; x = add x r1"
+	"; r1 = shr x 4; x = add x r1; x = and x 0x0f0f0f0f; x = mul x 0x01010101; x = shr x 24";
+enhance div10(x) micro "x = udiv x 10";		// becomes a multiply-high, no divide
+enhance hypot2(a, b) vm { 0 $ * ~ 0 $ * + };	// lifted from vm code
+enhance minmax(a, b) -> 2 micro "r2 = min a b; r1 = max a b; r0 = r2";
+let lo, hi;
+fn main()
+{
+	putn(popcount(0xff00ff)); putc(' ');
+	putn(div10(12345)); putc(' ');
+	putn(hypot2(3, 4)); putc(' ');
+	asm { 9 4 minmax hi ! lo ! }
+	putn(lo); putc('/'); putn(hi); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/genome.h b/docs/history/13-gap-fixes/code/genome.h
new file mode 100644
index 0000000..fecb1c9
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/genome.h
@@ -0,0 +1,4443 @@
+#define GORG 786432
+static const int genome[] = {
+1966081,1310721,4,1703963,14,852206,857446,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1572913,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,42,1572933,
+14,1,1310721,2,3,26,1310721,4,18,0,0,2,1,786486,0,786480,
+786482,786484,97,0,98,0,97,32,61,32,115,100,105,118,32,97,
+32,98,0,1,0,2,1,786512,0,786506,786508,786510,97,0,98,0,
+97,32,61,32,115,114,101,109,32,97,32,98,0,2,0,2,
+1,786538,0,786532,786534,786536,97,0,98,0,97,32,61,32,115,104,
+108,32,97,32,98,0,1310721,2,3,28,1310721,4,1310721,2,1835009,40,
+1573135,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,24,1,1573157,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,
+2,1835009,40,1573205,16,1966081,1310721,4,1579069,12,20,1573213,14,1,1310721,2,
+1,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1573261,
+16,1966081,1310721,4,1579069,12,22,1573269,14,1,1310721,2,1,26,1310721,4,
+18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1573317,16,1966081,1310721,4,
+1579069,12,0,1,1573327,14,1,1310721,2,1,26,1310721,4,18,1310721,2,
+5,28,1310721,4,1310721,2,1835009,40,1573375,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1,1310721,2,3,26,4,1310721,2,2,1310721,2,3,26,2,
+26,2,1573481,16,1310721,2,2,1310721,2,3,26,2,26,2,1573101,12,
+8,1310721,2,3,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1573393,14,1,1573489,14,1,1310721,2,5,26,1310721,4,18,1310721,
+2,29,28,1310721,4,1310721,2,1835009,40,1573537,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1,1310721,2,27,26,4,1310721,2,2,1,40,1573603,16,
+91,1573101,12,8,1310721,2,1,1310721,2,2,28,10,3,6,10,4,
+8,1310721,2,2,1,40,1573657,16,1573643,14,50,49,52,55,52,56,
+51,54,52,56,0,1573621,1573341,12,8,1,1573871,14,3,1573795,16,1310721,
+2,3,26,1310721,2,27,26,1,6,2,1,6,3,26,5,6,
+4,10,8,26,97,1310721,2,2,21,46,26,10,3,6,10,4,
+8,1310721,2,1310721,2,2,21,44,10,3,6,10,4,8,1310721,2,
+2,1,6,1,10,28,34,63,38,3,26,1573791,16,1573795,14,1573657,
+14,1310721,2,27,26,2,1573863,16,1310721,2,3,26,1310721,2,27,26,
+1,6,2,-1,26,1,6,5,6,4,10,8,26,2,1573101,12,
+8,1573795,14,1,1573871,14,1,1310721,2,29,26,1310721,4,18,1310721,2,
+5,28,1310721,4,1310721,2,1835009,40,1573919,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1,1310721,2,3,26,4,1310721,2,2,1310721,2,3,26,2,
+26,2,1573999,16,1310721,2,3,26,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1573937,14,1310721,2,3,26,2,1574015,14,1,1310721,
+2,5,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,
+1574063,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1,
+1310721,2,5,26,4,1310721,2,2,1310721,2,5,26,2,26,2,1574207,
+16,1310721,2,2,1310721,2,5,26,2,26,2,1310721,2,3,26,2,
+1310721,2,5,26,2,26,2,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1574209,14,1,
+1574251,16,1310721,2,5,26,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1574091,14,1310721,2,2,1310721,2,5,26,2,26,2,1310721,
+2,3,26,2,1310721,2,5,26,2,26,2,28,1,6,1,10,
+28,34,63,38,3,26,1574323,14,1,1310721,2,7,26,1310721,4,18,
+1310721,2,9,28,1310721,4,1310721,2,1835009,40,1574371,16,1966081,1310721,4,1579069,
+12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,1,1310721,
+2,7,26,4,1310721,2,7,26,2,1310721,2,5,26,2,40,1574527,
+16,1310721,2,2,1310721,2,7,26,2,26,1310721,2,3,26,2,1310721,
+2,7,26,2,26,2,10,3,6,10,4,8,1310721,2,7,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1574409,14,1,
+1574535,14,1,1310721,2,9,26,1310721,4,18,1310721,2,9,28,1310721,4,
+1310721,2,1835009,40,1574583,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,
+1310721,2,3,26,4,1310721,2,4,1,1310721,2,7,26,4,1310721,2,
+7,26,2,1310721,2,5,26,2,40,1574725,16,1310721,2,2,1310721,2,
+7,26,2,26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,
+2,7,26,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1574621,14,1,1574733,14,1,1310721,2,9,26,1310721,4,18,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,1310721,2,
+11,28,1310721,4,1310721,2,1835009,40,1574847,16,1966081,1310721,4,1579069,12,1310721,
+2,3,26,4,1310721,2,4,1,1310721,2,5,26,4,1,1310721,2,
+7,26,4,61,1310721,2,9,26,4,1310721,2,2,1310721,2,3,26,
+2,40,1574947,16,1574811,1310721,2,2,10,3,6,10,4,8,1,1575261,
+14,1310721,2,9,26,2,1,40,3,36,1575221,16,1310721,2,7,26,
+1310721,2,7,26,2,1310721,2,7,26,2,26,1310721,2,2,1310721,2,
+9,26,2,38,3,32,26,10,3,6,10,4,8,1310721,2,5,
+26,1310721,2,5,26,2,1310721,2,5,26,2,26,10,3,6,10,
+4,8,1310721,2,7,26,2,1310721,2,3,26,2,40,3,36,1575183,
+16,1310721,2,7,26,1310721,2,7,26,2,1310721,2,3,26,2,28,
+10,3,6,10,4,8,1310721,2,5,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1310721,2,9,26,1,6,2,1,6,
+-1,26,5,6,4,10,8,8,1574947,14,1574811,1310721,2,7,26,2,
+10,3,6,10,4,8,1310721,2,5,26,2,1575261,14,1,1310721,2,
+11,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1575309,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1,1310721,
+2,5,26,4,1310721,2,3,26,2,1,28,1,6,1,10,28,
+34,63,38,3,26,1575401,16,1574811,1310721,2,2,10,3,6,10,4,
+8,1,1575637,14,1310721,2,2,1,40,1575463,16,1310721,2,1,1310721,2,
+2,28,10,3,6,10,4,8,1310721,2,5,26,3,10,3,6,
+10,4,8,1310721,2,3,26,2,1,40,1575549,16,1310721,2,3,26,
+1,1310721,2,3,26,2,28,10,3,6,10,4,8,1310721,2,5,
+26,1310721,2,5,26,2,3,36,10,3,6,10,4,8,1310721,2,
+7,26,1310721,2,2,1310721,2,3,26,2,1574813,12,10,3,6,10,
+4,8,1310721,2,5,26,2,1575621,16,1,1310721,2,7,26,2,28,
+1575637,14,1310721,2,7,26,2,1575637,14,1,1310721,2,9,26,1310721,4,
+18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1575685,16,1966081,1310721,4,
+1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1,40,1310721,
+2,5,26,4,1310721,2,3,26,2,1,28,1,6,1,10,28,
+34,63,38,3,26,1575769,16,1310721,2,2,1575827,14,1310721,2,2,1310721,
+2,3,26,2,1575275,12,8,1310721,2,5,26,2,1575817,16,1,1574811,
+2,28,1575827,14,1574811,2,1575827,14,1,1310721,2,7,26,1310721,4,18,
+1310721,2,5,28,1310721,4,1310721,2,1835009,40,1575875,16,1966081,1310721,4,1579069,
+12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1574747,1310721,2,3,
+26,2,63,32,26,2,30,1575925,14,1,1310721,2,5,26,1310721,4,
+18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,1,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1576045,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,524289,28,1310721,2,3,26,
+4,1,1310721,2,5,26,4,1310721,2,3,26,2,1576341,16,1310721,2,
+7,26,3,10,3,6,10,4,8,1310721,2,7,26,2,1310721,2,
+7,26,2,26,1310721,2,3,26,2,10,40,3,36,1576205,16,1310721,
+2,7,26,1310721,2,7,26,2,1310721,2,7,26,2,26,10,3,
+6,10,4,8,1576115,14,1310721,2,2,1310721,2,5,26,2,1310721,2,
+7,26,2,26,40,1576253,16,1310721,2,7,26,2,1576349,14,1310721,2,
+5,26,1310721,2,5,26,2,1310721,2,7,26,2,26,10,3,6,
+10,4,8,1310721,2,3,26,1310721,2,3,26,2,1310721,2,7,26,
+2,28,10,3,6,10,4,8,1576079,14,1,1576349,14,1,1310721,2,
+9,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1576397,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,
+2,5,26,1,10,3,6,10,4,8,1310721,2,2,13,26,1575941,
+1310721,2,3,26,2,26,2,10,3,6,10,4,8,1310721,2,2,
+15,26,1,10,3,6,10,4,8,1575941,1310721,2,3,26,2,26,
+2,1576557,16,1575941,1310721,2,3,26,2,26,2,15,26,1310721,2,2,
+10,3,6,10,4,8,1575941,1310721,2,3,26,2,26,1310721,2,2,
+10,3,6,10,4,8,1,1576597,14,1,1310721,2,5,26,1310721,4,
+18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1576645,16,1966081,1310721,4,
+1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,15,26,2,
+1576721,16,1310721,2,2,15,26,2,13,26,1310721,2,2,13,26,2,
+10,3,6,10,4,8,1576759,14,1575941,1310721,2,3,26,2,26,1310721,
+2,2,13,26,2,10,3,6,10,4,8,1310721,2,2,13,26,
+2,1576815,16,1310721,2,2,13,26,2,15,26,1310721,2,2,15,26,
+2,10,3,6,10,4,8,1,1576823,14,1,1310721,2,5,26,1310721,
+4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1576871,16,1966081,1310721,
+4,1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1,26,
+1574747,1310721,2,3,26,2,26,2,10,3,6,10,4,8,1310721,2,
+2,3,26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,2,
+2,5,26,1,10,3,6,10,4,8,1310721,2,2,7,26,1,
+10,3,6,10,4,8,1310721,2,2,9,26,1,10,3,6,10,
+4,8,1310721,2,2,11,26,1,10,3,6,10,4,8,1310721,2,
+2,1577065,14,1,1310721,2,5,26,1310721,4,18,1310721,2,9,28,1310721,
+4,1310721,2,1835009,40,1577113,16,1966081,1310721,4,1579069,12,3,1310721,2,4,
+524289,1310721,2,3,26,4,1574747,1,26,3,10,3,6,10,4,8,
+1310721,2,2,65,40,1577257,16,1574747,1310721,2,2,26,1574747,1310721,2,2,
+3,28,26,2,1574747,1310721,2,2,3,28,26,2,26,10,3,6,
+10,4,8,1310721,2,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1577153,14,1575939,1310721,10,3,6,10,4,8,1575941,1,65,1574549,
+12,8,1310721,2,3,26,2,1310721,40,1577519,16,1310721,2,5,26,1310721,
+2,3,26,2,524289,28,1576011,12,10,3,6,10,4,8,1310721,2,
+7,26,1,10,3,6,10,4,8,1574747,1310721,2,7,26,2,26,
+2,1310721,2,5,26,2,40,1577433,16,1310721,2,7,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1577363,14,1310721,2,3,26,
+2,1310721,2,7,26,2,1576837,12,1310721,2,7,26,2,1576363,12,8,
+1310721,2,3,26,1310721,2,3,26,2,1310721,2,5,26,2,26,10,
+3,6,10,4,8,1577285,14,1,1577527,14,1,1310721,2,9,26,1310721,
+4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1577575,16,1966081,1310721,
+4,1579069,12,1310721,2,4,1310721,2,2,1310721,2,3,26,4,1310721,2,
+3,26,2,65,40,1577677,16,1575941,1310721,2,3,26,2,26,2,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1577679,14,1,1577721,16,1310721,2,3,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1577597,14,1310721,2,3,26,
+2,65,40,3,36,1577749,16,1,1577999,14,1310721,2,5,26,1575941,1310721,
+2,3,26,2,26,2,10,3,6,10,4,8,1310721,2,5,26,
+2,1310721,2,3,26,2,1576611,12,8,1310721,2,3,26,2,1310721,2,
+2,10,40,1577961,16,1310721,2,3,26,1,6,2,1,6,-1,26,
+5,6,4,10,8,8,1310721,2,7,26,1310721,2,5,26,2,1574747,
+1310721,2,3,26,2,26,2,26,10,3,6,10,4,8,1310721,2,
+7,26,2,1310721,2,3,26,2,1576837,12,1310721,2,3,26,2,1576363,
+12,8,1577811,14,1310721,2,5,26,2,1310721,2,2,1576837,12,8,1310721,
+2,5,26,2,1577999,14,1,1310721,2,9,26,1310721,4,18,0,1310721,
+2,11,28,1310721,4,1310721,2,1835009,40,1578049,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,3,26,2,1310721,2,3,26,4,1574747,1310721,
+2,3,26,2,26,2,1310721,2,5,26,4,3,1578721,16,1310721,2,
+7,26,1310721,2,2,524289,28,10,3,6,10,4,8,1310721,2,5,
+26,2,1310721,2,7,26,2,1576011,12,40,3,36,1578177,16,1578721,14,
+1310721,2,9,26,524289,1310721,2,7,26,2,1310721,2,5,26,2,36,
+26,10,3,6,10,4,8,1310721,2,9,26,2,5,26,2,1,
+28,1,6,1,10,28,34,63,38,1,10,28,1578275,16,3,1578347,
+14,1310721,2,9,26,2,3,26,2,1310721,2,3,26,2,28,1,
+6,1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,
+63,38,1,10,28,1578357,16,3,1578429,14,1310721,2,9,26,2,1,
+26,2,1310721,2,5,26,2,28,1,6,1,10,28,34,63,38,
+1,10,28,1,6,1,10,28,34,63,38,1,10,28,1578437,16,
+1578721,14,1310721,2,9,26,2,1310721,2,3,26,2,1576611,12,8,1310721,
+2,9,26,2,1310721,2,2,40,1578563,16,1310721,2,2,1,26,1,
+10,3,6,10,4,8,1310721,2,2,7,26,1,10,3,6,10,
+4,8,1310721,2,1310721,2,9,26,2,10,3,6,10,4,8,1578619,
+14,1310721,2,9,26,2,1,26,1,10,3,6,10,4,8,1310721,
+2,9,26,2,7,26,1,10,3,6,10,4,8,1310721,2,3,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1310721,2,
+5,26,1310721,2,5,26,2,1310721,2,5,26,2,26,10,3,6,
+10,4,8,1310721,2,2,1310721,2,3,26,2,1576837,12,8,1578103,14,
+1310721,2,2,1310721,2,3,26,2,1576837,12,1310721,2,3,26,2,1576363,
+12,8,1578013,1310721,2,2,1310721,2,5,26,2,26,10,3,6,10,
+4,8,1,1578797,14,1,1310721,2,11,26,1310721,4,18,1310721,2,3,
+28,1310721,4,1310721,2,1835009,40,1578845,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,524289,13,26,40,3,36,1578911,16,1310721,2,2,1575939,
+2,40,1,6,1,10,28,34,63,38,1,10,28,1578913,14,1,
+1578993,16,1310721,2,2,7,1,10,28,26,2,1310721,2,2,1459366445,36,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1578995,14,1,1579047,16,1310721,2,2,9,1,
+10,28,26,2,3,32,1,6,1,10,28,34,63,38,1,10,
+28,1579049,14,1,1579055,14,1,1310721,2,3,26,1310721,4,18,1310721,2,
+1,28,1310721,4,1310721,2,1835009,40,1579103,16,1966081,1310721,4,1579069,12,1579159,
+14,122,121,58,32,102,114,97,109,101,32,115,116,97,99,107,
+32,111,118,101,114,102,108,111,119,10,0,1579107,1573341,12,8,1573283,
+12,8,1,1579181,14,1,1310721,2,1,26,1310721,4,18,1310721,2,1,
+28,1310721,4,1310721,2,1835009,40,1579229,16,1966081,1310721,4,1579069,12,1579281,14,
+122,99,58,32,111,117,116,32,111,102,32,104,101,97,112,32,
+109,101,109,111,114,121,10,0,1579233,1573341,12,8,1573283,12,8,1,
+1579303,14,1,1310721,2,1,26,1310721,4,18,1310721,2,13,28,1310721,4,
+1310721,2,1835009,40,1579351,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,
+1310721,2,4,1310721,2,2,13,26,1310721,2,5,26,4,7,1310721,2,
+7,26,4,1310721,2,2,1,40,1579435,16,1310721,2,5,26,13,10,
+3,6,10,4,8,1574747,1310721,2,7,26,2,26,2,1310721,2,5,
+26,2,40,1579505,16,1310721,2,7,26,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1579435,14,1310721,2,9,26,1310721,2,7,26,
+2,1577541,12,10,3,6,10,4,8,1310721,2,9,26,2,1,6,
+1,10,28,34,63,38,3,26,1579603,16,1576009,2,1,6,1,10,
+28,34,63,38,1,10,28,1579605,14,1,1579649,16,1581445,12,8,1310721,
+2,9,26,1310721,2,7,26,2,1577541,12,10,3,6,10,4,8,
+1310721,2,9,26,2,1,6,1,10,28,34,63,38,3,26,1579689,
+16,1579195,12,8,1310721,2,11,26,1310721,2,9,26,2,13,26,10,
+3,6,10,4,8,1310721,2,9,26,2,5,26,3,10,3,6,
+10,4,8,1310721,2,9,26,2,7,26,1310721,2,11,26,2,1459366445,
+36,10,3,6,10,4,8,1310721,2,9,26,2,9,26,1,10,
+3,6,10,4,8,1310721,2,9,26,2,11,26,1310721,2,3,26,
+2,10,3,6,10,4,8,1310721,2,11,26,2,1,1574747,1310721,2,
+7,26,2,26,2,13,28,1574549,12,8,1310721,2,11,26,2,1579909,
+14,1,1310721,2,13,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,
+2,1835009,40,1579957,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,
+1,1579317,12,1579981,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,
+28,1310721,4,1310721,2,1835009,40,1580029,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,1578811,12,1,6,1,10,28,34,63,38,3,26,
+1580075,16,1,1580103,14,1310721,2,2,13,1,10,28,26,2,13,28,
+1580103,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1580151,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,
+2,1578811,12,1,6,1,10,28,34,63,38,3,26,1580197,16,1,
+1580221,14,1310721,2,2,3,1,10,28,26,2,1580221,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,11,28,1310721,4,1310721,2,1835009,40,1580269,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,13,28,1310721,2,
+3,26,4,1310721,2,3,26,2,1,26,2,13,28,1310721,2,5,
+26,4,1,1310721,2,7,26,4,1310721,2,3,26,2,5,26,1,
+10,3,6,10,4,8,1310721,2,7,26,2,1310721,2,5,26,2,
+40,1580585,16,1310721,2,9,26,1310721,2,2,1310721,2,7,26,2,26,
+2,10,3,6,10,4,8,1310721,2,9,26,2,1578811,12,1580525,16,
+1310721,2,9,26,2,5,1,10,28,26,2,1310721,2,2,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1580527,14,1,1580547,16,1310721,2,9,26,2,1580235,12,
+8,1310721,2,7,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1580365,14,1310721,2,3,26,2,1578015,12,8,1,1580609,14,1,
+1310721,2,11,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1580657,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1578811,12,
+1580689,16,1310721,2,2,1580235,12,8,1,1580697,14,1,1310721,2,3,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1580745,16,1966081,
+1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1578811,
+12,1580813,16,1310721,2,2,5,1,10,28,26,1310721,2,3,26,2,
+10,3,6,10,4,8,1310721,2,2,1580825,14,1,1310721,2,5,26,
+1310721,4,18,0,0,0,0,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1580881,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1578811,12,
+1,6,1,10,28,34,63,38,3,26,1580927,16,3,1580971,14,1310721,
+2,2,9,1,10,28,26,2,5,32,1,6,1,10,28,34,
+63,38,1,10,28,1580981,16,1,1581125,14,1310721,2,2,9,1,10,
+28,26,1310721,2,2,9,1,10,28,26,2,5,34,10,3,6,
+10,4,8,1580839,2,32769,40,1581101,16,2031617,1580839,2,26,1310721,2,2,
+10,3,6,10,4,8,1580839,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1581117,14,1580841,3,10,3,6,10,4,8,1,1581125,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1581173,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,
+2,4,1310721,2,2,1310721,2,3,26,2,40,1581259,16,1310721,2,2,
+2,1580847,12,8,1310721,2,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1581189,14,1,1581267,14,1,1310721,2,5,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1581315,16,1966081,1310721,4,1579069,
+12,1580839,2,1581423,16,1580839,1,6,2,1,6,-1,26,5,6,4,
+10,8,8,1310721,2,2031617,1580839,2,26,2,10,3,6,10,4,8,
+1310721,2,2,1310721,2,2,1310721,2,2,13,1,10,28,26,2,26,
+13,28,1581139,12,8,1581315,14,1,1581431,14,1,1310721,2,3,26,1310721,
+4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1581479,16,1966081,1310721,
+4,1579069,12,1,1310721,2,5,26,4,1580839,1,10,3,6,10,4,
+8,1580841,1,10,3,6,10,4,8,1700815,12,8,1581281,12,8,1580841,
+2,1581717,16,1580841,1,10,3,6,10,4,8,1310721,2,524289,10,3,
+6,10,4,8,1310721,2,2,1310721,40,1581713,16,1310721,2,2,5,26,
+2,7,28,1,6,1,10,28,34,63,38,3,26,1581667,16,1310721,
+2,2,13,26,1310721,2,2,1310721,2,2,1,26,2,26,1581139,12,
+8,1310721,2,1310721,2,2,1310721,2,2,1,26,2,26,10,3,6,
+10,4,8,1581281,12,8,1581577,14,1581535,14,1310721,2,524289,10,3,6,
+10,4,8,1310721,2,2,1310721,40,1581993,16,1310721,2,3,26,1310721,2,
+2,1,26,2,10,3,6,10,4,8,1310721,2,2,5,26,2,
+3,28,1,6,1,10,28,34,63,38,3,26,1581891,16,1310721,2,
+2,1578015,12,8,1310721,2,5,26,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1310721,2,1578013,2,10,3,6,10,4,8,1581989,
+14,1310721,2,2,5,26,2,7,28,1,6,1,10,28,34,63,
+38,3,26,1581955,16,1310721,2,2,5,26,3,10,3,6,10,4,
+8,1310721,2,1310721,2,2,1310721,2,3,26,2,26,10,3,6,10,
+4,8,1581735,14,1576005,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1576007,1576007,2,1310721,2,5,26,2,26,10,3,6,10,4,
+8,1310721,2,5,26,2,1582067,14,1,1310721,2,7,26,1310721,4,18,
+1310721,2,5,28,1310721,4,1310721,2,1835009,40,1582115,16,1966081,1310721,4,1579069,
+12,524289,1310721,2,4,1,1310721,2,3,26,4,1310721,2,2,1310721,40,
+1582243,16,1310721,2,2,5,26,2,3,32,1582203,16,1310721,2,3,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1310721,2,1310721,
+2,2,1310721,2,2,1,26,2,26,10,3,6,10,4,8,1582135,
+14,1310721,2,3,26,2,1582259,14,1,1310721,2,5,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1582307,16,1966081,1310721,4,1579069,
+12,63,1310721,2,4,1310721,2,2,1,10,40,1582389,16,1575941,1310721,2,
+2,26,2,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1582391,14,1,1582429,16,1310721,2,1,
+6,2,1,6,-1,26,5,6,4,10,8,8,1582315,14,1575941,1310721,
+2,2,26,2,1,6,1,10,28,34,63,38,3,26,1582471,16,
+1,1582489,14,1574747,1310721,2,2,26,2,1582489,14,1,1310721,2,3,26,
+1310721,4,18,0,0,0,0,0,0,0,0,0,0,0,0,791264,
+113,64,33,36,95,126,99,106,122,114,44,63,46,43,45,42,
+38,124,94,62,60,37,0,1,0,0,0,0,1,0,0,0,
+0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1585127,16,1966081,1310721,
+4,1579069,12,1585151,14,122,99,58,32,108,105,110,101,32,0,1585131,
+1573341,12,8,1582583,2,1573503,12,8,1585179,14,58,32,0,1585173,1573341,12,
+8,1585089,1,6,2,1,6,3,26,5,6,4,10,8,8,1,
+1585223,14,1,1310721,2,1,26,1310721,4,18,1310721,2,1,28,1310721,4,
+1310721,2,1835009,40,1585271,16,1966081,1310721,4,1579069,12,21,1573101,12,8,1585089,
+2,41,40,3,36,1585375,16,1585361,14,122,99,58,32,116,111,111,
+32,109,97,110,121,32,101,114,114,111,114,115,44,32,115,116,
+111,112,112,105,110,103,10,0,1585299,1573341,12,8,1573283,12,8,1,
+1585383,14,1,1310721,2,1,26,1310721,4,18,1310721,2,1,28,1310721,4,
+1310721,2,1835009,40,1585431,16,1966081,1310721,4,1579069,12,1585445,14,122,99,58,
+32,0,1585435,1573341,12,8,1585089,2,1573503,12,8,1585089,2,3,28,1,
+6,1,10,28,34,63,38,3,26,1585527,16,1585515,14,32,101,114,
+114,111,114,10,0,1585499,1573341,12,8,1585557,14,1585549,14,32,101,114,
+114,111,114,115,10,0,1585531,1573341,12,8,1573283,12,8,1,1585571,14,
+1,1310721,2,1,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,
+1835009,40,1585619,16,1966081,1310721,4,1579069,12,1310721,2,4,1585093,12,8,1310721,
+2,2,1573341,12,8,21,1573101,12,8,1573283,12,8,1,1585665,14,1,
+1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1585713,16,1966081,1310721,4,1579069,12,1310721,2,4,1585091,2,1,6,1,
+10,28,34,63,38,3,26,1585797,16,1584991,2,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1585799,14,1,1585827,16,1585093,12,8,1310721,2,2,1573341,12,8,1585237,12,
+8,1,1585835,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,
+1310721,4,1310721,2,1835009,40,1585883,16,1966081,1310721,4,1579069,12,1310721,2,3,
+26,4,1310721,2,4,1585091,2,1,6,1,10,28,34,63,38,3,
+26,1585977,16,1584991,2,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1585979,14,1,1586041,16,1585093,
+12,8,1310721,2,2,1573341,12,8,1586011,14,58,32,0,1586005,1573341,12,
+8,1310721,2,3,26,2,1573341,12,8,1585237,12,8,1,1586049,14,1,
+1310721,2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1586097,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1585679,12,
+8,1585091,3,10,3,6,10,4,8,1582577,2,1,28,1,6,1,
+10,28,34,63,38,3,26,1586169,16,1585397,12,8,1597071,12,8,1,
+1586183,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,
+1310721,2,1835009,40,1586231,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,
+1310721,2,4,1310721,2,2,1310721,2,3,26,2,1585849,12,8,1585091,3,
+10,3,6,10,4,8,1582577,2,1,28,1,6,1,10,28,34,
+63,38,3,26,1586323,16,1585397,12,8,1597071,12,8,1,1586337,14,1,
+1310721,2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1586385,16,1966081,1310721,4,1579069,12,1310721,2,4,1584853,2,1586429,16,1584857,
+2,1,6,1,10,28,34,63,38,1,10,28,1586431,14,1,1586447,
+16,1310721,2,2,1585679,12,8,1,1586455,14,1,1310721,2,3,26,1310721,
+4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1586503,16,1966081,1310721,
+4,1579069,12,1310721,2,3,26,4,1310721,2,4,1584853,2,1586557,16,1584857,
+2,1,6,1,10,28,34,63,38,1,10,28,1586559,14,1,1586591,
+16,1466881,1310721,2,2,26,2,1310721,2,3,26,2,1585849,12,8,1,
+1586599,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,1310721,4,
+1310721,2,1835009,40,1586647,16,1966081,1310721,4,1579069,12,1310721,2,4,1,1310721,
+2,3,26,4,1310721,2,2,2,1586755,16,1310721,2,3,26,1310721,2,
+3,26,2,63,30,1310721,2,2,2,26,10,3,6,10,4,8,
+1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,1586665,
+14,1310721,2,3,26,2,16385,3,28,32,1586779,14,1,1310721,2,5,
+26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1586827,16,
+1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1586613,12,1310721,2,3,
+26,4,3,1587017,16,1310721,2,5,26,1311233,1310721,2,3,26,2,26,
+2,10,3,6,10,4,8,1310721,2,5,26,2,1,6,1,10,
+28,34,63,38,3,26,1586933,16,1587017,14,1310721,2,5,26,2,1310721,
+2,2,1574029,12,1586971,16,1310721,2,5,26,2,1587297,14,1310721,2,3,
+26,1310721,2,3,26,2,3,26,16385,3,28,32,10,3,6,10,
+4,8,1586853,14,1310721,2,7,26,1310721,2,2,1573885,12,10,3,6,
+10,4,8,1582505,2,1310721,2,7,26,2,26,5,26,1409025,40,3,
+36,1587125,16,1587117,14,115,116,114,105,110,103,32,112,111,111,108,
+32,102,117,108,108,0,1587083,1585585,12,8,1582505,2,1,26,1,10,
+3,6,10,4,8,1310721,2,5,26,1582505,2,3,26,10,3,6,
+10,4,8,1310721,2,5,26,2,1310721,2,2,1310721,2,7,26,2,
+3,26,1574337,12,8,1582505,1582505,2,1310721,2,7,26,2,26,5,26,
+10,3,6,10,4,8,1311233,1310721,2,3,26,2,26,1310721,2,5,
+26,2,10,3,6,10,4,8,1310721,2,5,26,2,1587297,14,1,
+1310721,2,9,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,
+40,1587345,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,1310721,2,3,
+26,4,1310721,2,4,1582507,2,1310721,2,7,26,4,1582507,2,8193,40,
+3,36,1587449,16,1587441,14,115,121,109,98,111,108,32,116,97,98,
+108,101,32,102,117,108,108,0,1587405,1585585,12,8,1582507,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1409537,1310721,2,7,26,2,
+26,1310721,2,2,10,3,6,10,4,8,1417729,1310721,2,7,26,2,
+26,1310721,2,3,26,2,10,3,6,10,4,8,1425921,1310721,2,7,
+26,2,26,1310721,2,5,26,2,10,3,6,10,4,8,1434113,1310721,
+2,7,26,2,26,1,10,3,6,10,4,8,1442305,1310721,2,7,
+26,2,26,3,10,3,6,10,4,8,1450497,1310721,2,7,26,2,
+26,1,10,3,6,10,4,8,1559041,1310721,2,7,26,2,26,1,
+10,3,6,10,4,8,1458689,1310721,2,7,26,2,26,1310721,2,2,
+3,1,10,28,26,2,10,3,6,10,4,8,1310721,2,2,3,
+1,10,28,26,1310721,2,7,26,2,3,26,10,3,6,10,4,
+8,1310721,2,7,26,2,1587795,14,1,1310721,2,9,26,1310721,4,18,
+1310721,2,5,28,1310721,4,1310721,2,1835009,40,1587843,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1310721,2,2,3,1,10,28,26,2,3,28,1310721,
+2,3,26,4,1310721,2,3,26,2,1,40,3,36,1588129,16,1310721,
+2,3,26,2,1582511,2,40,3,36,1587933,16,3,1587995,14,1417729,1310721,
+2,3,26,2,26,2,11,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1588005,16,3,
+1588067,14,1417729,1310721,2,3,26,2,26,2,15,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1588085,16,1310721,2,3,26,2,1588143,14,1310721,2,3,26,1458689,1310721,
+2,3,26,2,26,2,3,28,10,3,6,10,4,8,1587881,14,
+3,1,10,28,1588143,14,1,1310721,2,5,26,1310721,4,18,1310721,2,
+3,28,1310721,4,1310721,2,1835009,40,1588191,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1582507,2,1310721,2,2,10,40,1588289,16,1582507,1,6,2,1,
+6,-1,26,5,6,4,10,8,8,1409537,1582507,2,26,2,3,1,
+10,28,26,1458689,1582507,2,26,2,10,3,6,10,4,8,1588197,14,
+1,1588297,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1588345,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,
+2,2,1586793,12,1587809,12,1588371,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,7,28,1310721,4,1310721,2,1835009,40,1588419,16,1966081,1310721,4,1579069,
+12,1310721,2,3,26,4,1310721,2,4,1582515,2,1310721,2,5,26,4,
+1310721,2,5,26,2,1588497,16,1582515,1491457,1310721,2,5,26,2,26,2,
+10,3,6,10,4,8,1588639,14,1582513,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1310721,2,5,26,1582513,2,10,3,6,10,
+4,8,1310721,2,5,26,2,16385,40,3,36,1588639,16,1588631,14,116,
+111,111,32,109,97,110,121,32,102,111,114,119,97,114,100,32,
+114,101,102,101,114,101,110,99,101,115,0,1588575,1585585,12,8,1475073,
+1310721,2,5,26,2,26,1310721,2,2,10,3,6,10,4,8,1491457,
+1310721,2,5,26,2,26,1310721,2,3,26,2,10,3,6,10,4,
+8,1310721,2,5,26,2,1588723,14,1,1310721,2,7,26,1310721,4,18,
+1310721,2,7,28,1310721,4,1310721,2,1835009,40,1588771,16,1966081,1310721,4,1579069,
+12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1588933,16,1475073,1310721,
+2,2,26,2,1310721,2,3,26,2,1589317,12,8,1310721,2,5,26,
+1491457,1310721,2,2,26,2,10,3,6,10,4,8,1491457,1310721,2,2,
+26,1582515,2,10,3,6,10,4,8,1582515,1310721,2,2,10,3,6,
+10,4,8,1310721,2,1310721,2,5,26,2,10,3,6,10,4,8,
+1588787,14,1,1588941,14,1,1310721,2,7,26,1310721,4,18,1310721,2,3,
+28,1310721,4,1310721,2,1835009,40,1588989,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1584991,2,1589009,16,1,1589135,14,1584837,2,1584841,2,40,3,36,1589071,
+16,1589063,14,112,114,111,103,114,97,109,32,116,111,111,32,98,
+105,103,0,1589031,1585585,12,8,1584837,2,1584839,2,26,1310721,2,2,10,
+3,6,10,4,8,1584837,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1,1589135,14,1,1310721,2,3,26,1310721,4,18,1310721,2,
+3,28,1310721,4,1310721,2,1835009,40,1589183,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1310721,2,2,1310721,2,2,26,3,26,1588955,12,8,1,1589221,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,
+2,1835009,40,1589269,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,
+1310721,2,2,26,1588955,12,8,1,1589303,14,1,1310721,2,3,26,1310721,
+4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1589351,16,1966081,1310721,
+4,1579069,12,1310721,2,3,26,4,1310721,2,4,1584991,2,1589381,16,1,
+1589439,14,1310721,2,2,1584839,2,26,1310721,2,3,26,2,1310721,2,3,
+26,2,26,3,26,10,3,6,10,4,8,1,1589439,14,1,1310721,
+2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,
+1589487,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1589149,12,8,
+15,1589235,12,8,1,1589521,14,1,1310721,2,3,26,1310721,4,18,1310721,
+2,3,28,1310721,4,1310721,2,1835009,40,1589569,16,1966081,1310721,4,1579069,12,
+1584837,2,1310721,2,4,2097153,3,28,1589149,12,8,1310721,2,2,1589603,14,
+1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,
+1835009,40,1589651,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,3,
+1582583,2,1587311,12,1310721,2,3,26,4,1442305,1310721,2,3,26,2,26,
+1,10,3,6,10,4,8,1310721,2,3,26,2,1589727,14,1,1310721,
+2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,
+1589775,16,1966081,1310721,4,1579069,12,1310721,2,4,1442305,1310721,2,2,26,2,
+3,32,1589825,16,1425921,1310721,2,2,26,2,1589149,12,8,1,1589901,14,
+1584991,2,1589839,16,1,1589901,14,1450497,1310721,2,2,26,1584837,2,1450497,1310721,
+2,2,26,2,1588385,12,10,3,6,10,4,8,2097153,3,28,1589149,
+12,8,1,1589901,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1589949,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,1587809,12,1310721,2,3,26,4,1310721,2,3,26,2,
+1,40,1590023,16,1310721,2,3,26,1310721,2,2,1589617,12,10,3,6,
+10,4,8,1310721,2,3,26,2,1589741,12,8,13,1589235,12,8,1,
+1590055,14,1,1310721,2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1590103,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,1589149,
+12,8,3,1589235,12,8,1310721,2,2,1590155,16,1310721,2,2,1589149,12,
+8,27,1589235,12,8,1,1590163,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,7,28,1310721,4,1310721,2,1835009,40,1590211,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1589535,12,1310721,2,3,26,4,15,1589235,12,8,1310721,
+2,5,26,1584837,2,10,3,6,10,4,8,1310721,2,2,2,1590323,
+16,1310721,2,2,2,1588955,12,8,1310721,2,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1590263,14,1,1588955,12,8,1310721,2,3,
+26,2,1584837,2,1589317,12,8,1310721,2,5,26,2,1589149,12,8,1,
+1590375,14,1,1310721,2,7,26,1310721,4,18,1310721,2,1,28,1310721,4,
+1310721,2,1835009,40,1590423,16,1966081,1310721,4,1579069,12,1582589,2,1,28,1,
+6,1,10,28,34,63,38,3,26,1590629,16,1582595,2,1590469,16,3,
+1590495,14,1573227,12,1,6,1,10,28,34,63,38,1,10,28,1590527,
+16,1582587,3,1,10,28,10,3,6,10,4,8,1,1590929,14,1582587,
+1573171,12,511,32,10,3,6,10,4,8,1582587,2,193,28,1,6,
+1,10,28,34,63,38,3,26,1590625,16,1582595,3,10,3,6,10,
+4,8,1582587,3,1,10,28,10,3,6,10,4,8,1,1590929,14,
+1590861,14,1582589,2,7,28,1,6,1,10,28,34,63,38,3,26,
+1590775,16,1582587,1582593,2,1582591,2,5,38,26,2,1582591,2,7,32,17,
+30,38,511,32,10,3,6,10,4,8,1582587,2,1590749,16,1582591,1,
+6,2,1,6,3,26,5,6,4,10,8,8,1590771,14,1582587,3,
+1,10,28,10,3,6,10,4,8,1590861,14,1582587,1582591,2,2,511,
+32,10,3,6,10,4,8,1582587,2,1590839,16,1582591,1,6,2,1,
+6,3,26,5,6,4,10,8,8,1590861,14,1582587,3,1,10,28,
+10,3,6,10,4,8,1582587,2,21,28,1,6,1,10,28,34,
+63,38,3,26,1590921,16,1582585,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1,1590929,14,1,1310721,2,1,26,1310721,4,18,1310721,
+2,13,28,1310721,4,1310721,2,1835009,40,1590977,16,1966081,1310721,4,1579069,12,
+1310721,2,7,26,4,1310721,2,5,26,4,1310721,2,3,26,4,1310721,
+2,4,1582597,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1582597,2,65,40,3,36,1591121,16,1591113,14,115,111,117,114,99,101,
+115,32,110,101,115,116,101,100,32,116,111,111,32,100,101,101,
+112,108,121,0,1591061,1585585,12,8,1310721,2,9,26,1540609,1582597,2,65,
+30,26,10,3,6,10,4,8,1310721,2,9,26,2,1,26,1310721,
+2,2,10,3,6,10,4,8,1310721,2,9,26,2,3,26,1310721,
+2,3,26,2,10,3,6,10,4,8,1310721,2,9,26,2,5,
+26,1,10,3,6,10,4,8,1310721,2,9,26,2,7,26,1,
+10,3,6,10,4,8,1310721,2,9,26,2,9,26,1310721,2,5,
+26,2,10,3,6,10,4,8,1310721,2,9,26,2,23,26,1310721,
+2,7,26,2,10,3,6,10,4,8,1310721,2,9,26,2,11,
+26,1582577,2,10,3,6,10,4,8,1310721,2,9,26,2,13,26,
+1582579,2,10,3,6,10,4,8,1310721,2,9,26,2,15,26,1582581,
+2,10,3,6,10,4,8,1310721,2,9,26,2,17,26,1582587,2,
+10,3,6,10,4,8,1310721,2,9,26,2,19,26,1582589,2,10,
+3,6,10,4,8,1310721,2,9,26,2,21,26,1582591,2,10,3,
+6,10,4,8,1310721,2,9,26,2,25,26,1582585,2,10,3,6,
+10,4,8,1310721,2,9,26,2,27,26,1582583,2,10,3,6,10,
+4,8,1310721,2,9,26,2,29,26,1584803,2,10,3,6,10,4,
+8,1310721,2,9,26,2,63,26,1582593,2,10,3,6,10,4,8,
+1310721,2,11,26,1,10,3,6,10,4,8,1310721,2,11,26,2,
+1584803,2,40,1591961,16,1310721,2,9,26,2,31,1310721,2,11,26,2,
+9,30,26,26,1584805,1310721,2,11,26,2,26,2,10,3,6,10,
+4,8,1310721,2,9,26,2,33,1310721,2,11,26,2,9,30,26,
+26,1584813,1310721,2,11,26,2,26,2,10,3,6,10,4,8,1310721,
+2,9,26,2,35,1310721,2,11,26,2,9,30,26,26,1584821,1310721,
+2,11,26,2,26,2,10,3,6,10,4,8,1310721,2,9,26,
+2,37,1310721,2,11,26,2,9,30,26,26,1584829,1310721,2,11,26,
+2,26,2,10,3,6,10,4,8,1310721,2,11,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1591671,14,1584803,1,10,3,
+6,10,4,8,1310721,2,2,3,28,1,6,1,10,28,34,63,
+38,3,26,1592053,16,1310721,2,9,26,2,7,26,1310721,2,3,26,
+2,1,26,2,10,3,6,10,4,8,1310721,2,2,1,28,1,
+6,1,10,28,34,63,38,3,26,1592141,16,1582589,1,10,3,6,
+10,4,8,1582595,1,10,3,6,10,4,8,1582585,3,10,3,6,
+10,4,8,1590389,12,8,1310721,2,2,5,28,1,6,1,10,28,
+34,63,38,3,26,1592237,16,1582589,5,10,3,6,10,4,8,1582591,
+1310721,2,3,26,2,10,3,6,10,4,8,1582585,3,10,3,6,
+10,4,8,1590389,12,8,1310721,2,2,7,28,1,6,1,10,28,
+34,63,38,3,26,1592349,16,1582589,7,10,3,6,10,4,8,1582593,
+1310721,2,3,26,2,10,3,6,10,4,8,1582591,1,10,3,6,
+10,4,8,1582585,3,10,3,6,10,4,8,1590389,12,8,1,1592357,
+14,1,1310721,2,13,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1592405,16,1966081,1310721,4,1579069,12,1540609,1582597,2,65,30,26,
+1310721,2,4,1,1310721,2,3,26,4,1582577,1310721,2,2,11,26,2,
+10,3,6,10,4,8,1582579,1310721,2,2,13,26,2,10,3,6,
+10,4,8,1582581,1310721,2,2,15,26,2,10,3,6,10,4,8,
+1582587,1310721,2,2,17,26,2,10,3,6,10,4,8,1582589,1310721,2,
+2,19,26,2,10,3,6,10,4,8,1582591,1310721,2,2,21,26,
+2,10,3,6,10,4,8,1582585,1310721,2,2,25,26,2,10,3,
+6,10,4,8,1582583,1310721,2,2,27,26,2,10,3,6,10,4,
+8,1584803,1310721,2,2,29,26,2,10,3,6,10,4,8,1582593,1310721,
+2,2,63,26,2,10,3,6,10,4,8,1310721,2,3,26,2,
+1584803,2,40,1592969,16,1584805,1310721,2,3,26,2,26,1310721,2,2,31,
+1310721,2,3,26,2,9,30,26,26,2,10,3,6,10,4,8,
+1584813,1310721,2,3,26,2,26,1310721,2,2,33,1310721,2,3,26,2,
+9,30,26,26,2,10,3,6,10,4,8,1584821,1310721,2,3,26,
+2,26,1310721,2,2,35,1310721,2,3,26,2,9,30,26,26,2,
+10,3,6,10,4,8,1584829,1310721,2,3,26,2,26,1310721,2,2,
+37,1310721,2,3,26,2,9,30,26,26,2,10,3,6,10,4,
+8,1310721,2,3,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1592695,14,1582597,1,6,2,1,6,-1,26,5,6,4,10,
+8,8,1310721,2,2,23,26,2,1593031,16,1310721,2,2,3,26,2,
+1580623,12,8,1,1593039,14,1,1310721,2,5,26,1310721,4,18,1310721,2,
+5,28,1310721,4,1310721,2,1835009,40,1593087,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1593137,14,43,45,42,47,37,61,60,62,33,38,124,94,
+126,63,58,46,64,35,36,0,1593097,1310721,2,3,26,4,1310721,2,
+3,26,2,2,1593253,16,1310721,2,3,26,2,2,1310721,2,2,28,
+1,6,1,10,28,34,63,38,3,26,1593215,16,3,1593261,14,1310721,
+2,3,26,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1593149,14,1,1593261,14,1,1310721,2,5,26,1310721,4,18,1310721,2,11,
+28,1310721,4,1310721,2,1835009,40,1593309,16,1966081,1310721,4,1579069,12,1310721,2,
+3,26,4,1310721,2,4,1,1310721,2,5,26,4,1310721,2,5,26,
+2,1582523,2,40,1593739,16,1310721,2,7,26,1547777,1310721,2,5,26,2,
+26,2,10,3,6,10,4,8,1310721,2,9,26,1,10,3,6,
+10,4,8,1310721,2,9,26,2,1310721,2,2,40,1593525,16,1310721,2,
+7,26,2,1310721,2,9,26,2,26,2,1582599,1310721,2,9,26,2,
+26,2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1593527,14,1,1593569,16,1310721,2,9,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1593415,14,
+1310721,2,9,26,2,1310721,2,2,28,1,6,1,10,28,34,63,
+38,3,26,1593689,16,1310721,2,7,26,2,1310721,2,2,26,2,1310721,
+2,3,26,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1593691,14,1,1593701,16,3,
+1593747,14,1310721,2,5,26,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1593337,14,1,1593747,14,1,1310721,2,11,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1593795,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1310721,2,2,97,40,3,36,1593861,16,1310721,2,2,
+115,10,40,3,36,1,6,1,10,28,34,63,38,1,10,28,
+1593863,14,1,1593869,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,
+28,1310721,4,1310721,2,1835009,40,1593917,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,195,40,3,36,1593983,16,1310721,2,2,245,10,40,
+3,36,1,6,1,10,28,34,63,38,1,10,28,1593985,14,1,
+1593995,16,3,1594079,14,1310721,2,2,131,40,3,36,1594055,16,1310721,2,
+2,181,10,40,3,36,1,6,1,10,28,34,63,38,1,10,
+28,1594057,14,1,1,6,1,10,28,34,63,38,1,10,28,1594089,
+16,3,1594141,14,1310721,2,2,191,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1594147,14,
+1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,
+1835009,40,1594195,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1593761,
+12,1594229,16,1310721,2,2,97,28,1594411,14,1310721,2,2,195,40,3,
+36,1594289,16,1310721,2,2,205,10,40,3,36,1,6,1,10,28,
+34,63,38,1,10,28,1594291,14,1,1594313,16,1310721,2,2,195,28,
+21,26,1594411,14,1310721,2,2,131,40,3,36,1594373,16,1310721,2,2,
+141,10,40,3,36,1,6,1,10,28,34,63,38,1,10,28,
+1594375,14,1,1594397,16,1310721,2,2,131,28,21,26,1594411,14,3,1,
+10,28,1594411,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1594459,16,1966081,1310721,4,1579069,12,1582587,2,1310721,
+2,4,1590389,12,8,1310721,2,2,185,28,1,6,1,10,28,34,
+63,38,1,10,28,1594521,16,1310721,2,2,1594759,14,1310721,2,1582587,2,
+10,3,6,10,4,8,1590389,12,8,1310721,2,2,221,28,1,6,
+1,10,28,34,63,38,3,26,1594587,16,21,1594759,14,1310721,2,2,
+233,28,1,6,1,10,28,34,63,38,3,26,1594627,16,19,1594759,
+14,1310721,2,2,229,28,1,6,1,10,28,34,63,38,3,26,
+1594667,16,27,1594759,14,1310721,2,2,97,28,1,6,1,10,28,34,
+63,38,3,26,1594707,16,1,1594759,14,1310721,2,2,203,28,1,6,
+1,10,28,34,63,38,3,26,1594747,16,55,1594759,14,1310721,2,2,
+1594759,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1594807,16,1966081,1310721,4,1579069,12,1310721,2,4,1582587,2,
+1,40,3,36,1594863,16,1582587,2,1593053,12,1,6,1,10,28,34,
+63,38,1,10,28,1594865,14,1,1594909,16,1310721,2,2,1582587,2,1593275,
+12,1,6,1,10,28,34,63,38,1,10,28,1594911,14,1,1594981,
+16,1582599,1310721,2,2,26,1582587,2,10,3,6,10,4,8,1310721,2,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1590389,12,8,
+1594813,14,1582599,1310721,2,2,26,1,10,3,6,10,4,8,1582577,9,
+10,3,6,10,4,8,1582579,1582599,1586793,12,10,3,6,10,4,8,
+1,1595049,14,1,1310721,2,3,26,1310721,4,18,1310721,2,7,28,1310721,
+4,1310721,2,1835009,40,1595097,16,1966081,1310721,4,1579069,12,1,1310721,2,4,
+1582581,3,10,3,6,10,4,8,3,1595773,16,1582587,2,65,28,1,
+6,1,10,28,34,63,38,3,26,1595165,16,3,1595215,14,1582587,2,
+19,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1595225,16,3,1595275,14,1582587,2,21,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1595285,16,3,1595335,14,1582587,2,27,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1595365,16,1590389,12,8,1582581,1,10,3,6,10,4,8,
+1595127,14,1582587,2,95,28,1,6,1,10,28,34,63,38,1,10,
+28,1595403,16,1595773,14,1590389,12,8,1582587,2,95,28,1,6,1,10,
+28,34,63,38,3,26,1595549,16,1582587,2,1,40,3,36,1595513,16,
+1582587,2,21,28,1,6,1,10,28,34,63,38,1,10,28,1,
+6,1,10,28,34,63,38,1,10,28,1595515,14,1,1595529,16,1590389,
+12,8,1595441,14,1582581,1,10,3,6,10,4,8,1595121,14,1582587,2,
+85,28,1,6,1,10,28,34,63,38,3,26,1595717,16,1590389,12,
+8,1582587,2,1,40,3,36,1595691,16,1582587,2,85,28,1,6,1,
+10,28,34,63,38,3,26,1595681,16,1590389,12,8,1582587,2,95,28,
+1,6,1,10,28,34,63,38,3,26,1595677,16,1595691,14,1595687,14,
+1590389,12,8,1595587,14,1590389,12,8,1582581,1,10,3,6,10,4,8,
+1595121,14,1582583,1582585,2,10,3,6,10,4,8,1582599,1,26,95,10,
+3,6,10,4,8,3,1594773,12,8,1,1597057,14,1595121,14,1582583,1582585,
+2,10,3,6,10,4,8,1582587,2,1,40,1595841,16,1582577,1,10,
+3,6,10,4,8,1582579,1,10,3,6,10,4,8,1,1597057,14,
+1582587,2,1593761,12,1596263,16,1310721,2,3,26,1,10,3,6,10,4,
+8,1582587,2,97,28,1,6,1,10,28,34,63,38,3,26,1596151,
+16,1590389,12,8,1582587,2,241,28,1,6,1,10,28,34,63,38,
+3,26,1595951,16,3,1596001,14,1582587,2,177,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1596151,16,1590389,12,8,1310721,2,5,26,1582587,2,1594161,12,10,3,6,
+10,4,1,40,3,36,1596105,16,1310721,2,3,26,1310721,2,3,26,
+2,33,30,1310721,2,5,26,2,26,10,3,6,10,4,8,1590389,
+12,8,1596011,14,1582577,3,10,3,6,10,4,8,1582579,1310721,2,3,
+26,2,10,3,6,10,4,8,1,1597057,14,1582587,2,1593761,12,1596217,
+16,1310721,2,3,26,1310721,2,3,26,2,21,30,1582587,2,26,97,
+28,10,3,6,10,4,8,1590389,12,8,1596151,14,1582577,3,10,3,
+6,10,4,8,1582579,1310721,2,3,26,2,10,3,6,10,4,8,
+1,1597057,14,1582587,2,1593883,12,1596473,16,1582587,2,1593883,12,1596293,16,3,
+1596323,14,1582587,2,1593761,12,1,6,1,10,28,34,63,38,1,10,
+28,1596407,16,1310721,2,2,2001,40,1596397,16,1582599,1310721,2,2,26,1582587,
+2,10,3,6,10,4,8,1310721,2,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1590389,12,8,1596275,14,1582599,1310721,2,2,26,
+1,10,3,6,10,4,8,1582577,5,10,3,6,10,4,8,1582579,
+1582599,1586793,12,10,3,6,10,4,8,1,1597057,14,1582587,2,79,28,
+1,6,1,10,28,34,63,38,3,26,1596647,16,1590389,12,8,1582579,
+1594425,12,10,3,6,10,4,8,1582587,2,79,28,1,6,1,10,
+28,34,63,38,1,10,28,1596619,16,1596611,14,98,97,100,32,99,
+104,97,114,97,99,116,101,114,32,108,105,116,101,114,97,108,
+0,1596567,1586063,12,8,1590389,12,8,1582577,3,10,3,6,10,4,8,
+1,1597057,14,1582587,2,69,28,1,6,1,10,28,34,63,38,3,
+26,1596939,16,1590389,12,8,1582587,2,1,40,3,36,1596757,16,1582587,2,
+69,28,1,6,1,10,28,34,63,38,1,10,28,1,6,1,
+10,28,34,63,38,1,10,28,1596759,14,1,1596867,16,1310721,2,3,
+26,1594425,12,10,3,6,10,4,8,1310721,2,2,2001,40,1596863,16,
+1582599,1310721,2,2,26,1310721,2,3,26,2,10,3,6,10,4,8,
+1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,1596685,
+14,1590389,12,8,1582599,1310721,2,2,26,1,10,3,6,10,4,8,
+1582577,7,10,3,6,10,4,8,1582579,1582599,1586793,12,10,3,6,10,
+4,8,1,1597057,14,1582599,1,26,1582587,2,10,3,6,10,4,8,
+1590389,12,8,1582599,1,26,2,1593053,12,1596993,16,3,1594773,12,1597057,14,
+1582599,3,26,1,10,3,6,10,4,8,1582577,9,10,3,6,10,
+4,8,1582579,1582599,1586793,12,10,3,6,10,4,8,1,1597057,14,1,
+1310721,2,7,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1597105,16,1966081,1310721,4,1579069,12,3,1310721,2,4,1584803,2,1597445,16,
+1582577,1584805,1,26,2,10,3,6,10,4,8,1582579,1584813,1,26,2,
+10,3,6,10,4,8,1582581,1584821,1,26,2,10,3,6,10,4,
+8,1582583,1584829,1,26,2,10,3,6,10,4,8,1310721,2,2,1584803,
+2,40,1597411,16,1584805,1310721,2,2,3,28,26,1584805,1310721,2,2,26,
+2,10,3,6,10,4,8,1584813,1310721,2,2,3,28,26,1584813,1310721,
+2,2,26,2,10,3,6,10,4,8,1584821,1310721,2,2,3,28,
+26,1584821,1310721,2,2,26,2,10,3,6,10,4,8,1584829,1310721,2,
+2,3,28,26,1584829,1310721,2,2,26,2,10,3,6,10,4,8,
+1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,1597209,
+14,1584803,1,6,2,1,6,-1,26,5,6,4,10,8,8,1,
+1597455,14,1597991,12,1597455,14,1,1310721,2,3,26,1310721,4,18,1310721,2,
+11,28,1310721,4,1310721,2,1835009,40,1597503,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1584803,2,1310721,2,2,10,40,3,36,1597857,16,1310721,2,3,
+26,1582577,2,10,3,6,10,4,8,1310721,2,5,26,1582579,2,10,
+3,6,10,4,8,1310721,2,7,26,1582581,2,10,3,6,10,4,
+8,1310721,2,9,26,1582583,2,10,3,6,10,4,8,1597991,12,8,
+1584805,1584803,2,26,1582577,2,10,3,6,10,4,8,1584813,1584803,2,26,
+1582579,2,10,3,6,10,4,8,1584821,1584803,2,26,1582581,2,10,3,
+6,10,4,8,1584829,1584803,2,26,1582583,2,10,3,6,10,4,8,
+1584803,1,6,2,1,6,3,26,5,6,4,10,8,8,1582577,1310721,
+2,3,26,2,10,3,6,10,4,8,1582579,1310721,2,5,26,2,
+10,3,6,10,4,8,1582581,1310721,2,7,26,2,10,3,6,10,
+4,8,1582583,1310721,2,9,26,2,10,3,6,10,4,8,1597509,14,
+1584799,1584805,1310721,2,2,26,2,10,3,6,10,4,8,1584801,1584813,1310721,
+2,2,26,2,10,3,6,10,4,8,1,1597917,14,1,1310721,2,
+11,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1597965,
+16,1966081,1310721,4,1579069,12,1,1597469,12,1597977,14,1,1310721,2,1,26,
+1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1598025,16,1966081,
+1310721,4,1579069,12,1310721,2,1540609,1582597,2,65,30,26,10,3,6,10,
+4,8,1310721,2,2,1,26,2,3,28,1,6,1,10,28,34,
+63,38,1,10,28,1598107,16,1595063,12,8,1,1598483,14,1310721,2,5,
+26,1310721,2,2,5,26,2,10,3,6,10,4,8,1310721,2,5,
+26,2,1310721,2,2,7,26,2,40,1598395,16,1310721,2,3,26,1310721,
+2,2,3,26,2,10,3,6,10,4,8,1582577,1310721,2,3,26,
+2,3,1310721,2,5,26,2,7,30,26,26,2,10,3,6,10,
+4,8,1582579,1310721,2,3,26,2,5,1310721,2,5,26,2,7,30,
+26,26,2,10,3,6,10,4,8,1582583,1310721,2,3,26,2,7,
+1310721,2,5,26,2,7,30,26,26,2,10,3,6,10,4,8,
+1582581,1,10,3,6,10,4,8,1310721,2,2,5,26,1310721,2,5,
+26,2,3,26,10,3,6,10,4,8,1,1598483,14,1310721,2,2,
+9,26,2,1,6,1,10,28,34,63,38,3,26,1598469,16,1582577,
+1,10,3,6,10,4,8,1582579,1,10,3,6,10,4,8,1,
+1598483,14,1592371,12,8,1,1598483,14,1,1310721,2,7,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1598531,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1582577,2,9,28,1,6,1,10,28,34,63,38,
+3,26,1598627,16,1582579,2,1310721,2,2,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1598629,
+14,1,1598635,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1598683,16,1966081,1310721,4,1579069,12,1310721,2,4,
+1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,1598779,16,
+1582579,2,1310721,2,2,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1598781,14,1,1598787,14,
+1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,
+1835009,40,1598835,16,1966081,1310721,4,1579069,12,1310721,2,4,1582577,2,9,28,
+1,6,1,10,28,34,63,38,3,26,1598879,16,3,1598929,14,1582577,
+2,5,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1598991,16,1582579,2,1310721,2,2,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1598993,14,1,1599009,16,1597071,12,8,3,1599017,14,
+1,1599017,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1599065,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,
+2,2,1598801,12,1,6,1,10,28,34,63,38,3,26,1599299,16,
+1585091,2,1,6,1,10,28,34,63,38,3,26,1599183,16,1584991,2,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1599185,14,1,1599245,16,1585093,12,8,1599219,14,101,
+120,112,101,99,116,101,100,32,0,1599199,1573341,12,8,1310721,2,2,
+1573341,12,8,1585237,12,8,1585091,3,10,3,6,10,4,8,1582577,2,
+1,28,1,6,1,10,28,34,63,38,3,26,1599299,16,1585397,12,
+8,1,1599307,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1599355,16,1966081,1310721,4,1579069,12,1582579,2,1310721,
+2,4,1582577,2,5,28,1,6,1,10,28,34,63,38,1,10,
+28,1599443,16,1599435,14,101,120,112,101,99,116,101,100,32,97,32,
+110,97,109,101,0,1599403,1586063,12,8,1597071,12,8,1310721,2,2,1599461,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,
+2,1835009,40,1599509,16,1966081,1310721,4,1579069,12,1310721,2,4,1582525,2,1310721,
+2,3,26,4,3,1600583,16,1310721,2,2,2,65,28,1,6,1,
+10,28,34,63,38,3,26,1599605,16,1310721,2,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1599535,14,1310721,2,2,2,1,6,
+1,10,28,34,63,38,3,26,1599641,16,1600583,14,1310721,2,5,26,
+1,10,3,6,10,4,8,1310721,2,2,1310721,2,5,26,2,26,
+2,1599759,16,1310721,2,2,1310721,2,5,26,2,26,2,65,28,1,
+6,1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,
+63,38,1,10,28,1599761,14,1,1599849,16,1582599,1310721,2,5,26,2,
+26,1310721,2,2,1310721,2,5,26,2,26,2,10,3,6,10,4,
+8,1310721,2,5,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1599663,14,1582599,1310721,2,5,26,2,26,1,10,3,6,10,
+4,8,1310721,2,1310721,2,2,1310721,2,5,26,2,26,10,3,6,
+10,4,8,1310721,2,7,26,1582599,1,26,2,91,28,1,6,1,
+10,28,34,63,38,3,26,1599993,16,1582599,3,26,2,1593761,12,1,
+6,1,10,28,34,63,38,1,10,28,1599995,14,1,10,3,6,
+10,4,8,1582599,1310721,2,7,26,2,26,2,1593761,12,1600323,16,1310721,
+2,9,26,1,10,3,6,10,4,8,1310721,2,11,26,1310721,2,
+7,26,2,10,3,6,10,4,8,1582599,1310721,2,11,26,2,26,
+2,1600197,16,1310721,2,9,26,1310721,2,9,26,2,21,30,1582599,1310721,
+2,11,26,2,26,2,26,97,28,10,3,6,10,4,8,1310721,
+2,11,26,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1600083,14,1310721,2,7,26,2,1600245,16,1310721,2,9,26,1,1310721,2,
+9,26,2,28,10,3,6,10,4,8,1542657,1582525,2,26,1310721,2,
+9,26,2,1310721,2,9,26,2,26,3,26,10,3,6,10,4,
+8,1582525,1,6,2,1,6,3,26,5,6,4,10,8,8,1600579,
+14,1310721,2,5,26,2,3,28,1,6,1,10,28,34,63,38,
+3,26,1600425,16,1310721,2,13,26,1582599,1,26,2,1600613,12,10,3,
+6,10,4,1,40,3,36,1,6,1,10,28,34,63,38,1,
+10,28,1600427,14,1,1600505,16,1542657,1582525,2,26,1310721,2,13,26,2,
+1310721,2,13,26,2,26,10,3,6,10,4,8,1582525,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1600579,14,1542657,1582525,2,26,
+-3,10,3,6,10,4,8,1542657,1582525,2,3,26,26,1582599,1586793,12,
+10,3,6,10,4,8,1582525,1582525,2,5,26,10,3,6,10,4,
+8,1599529,14,1310721,2,3,26,2,1600599,14,1,1310721,2,15,26,1310721,
+4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1600647,16,1966081,1310721,
+4,1579069,12,1310721,2,4,1,1310721,2,3,26,4,1582527,2,1310721,2,
+3,26,2,26,2,1600789,16,1582527,2,1310721,2,3,26,2,26,2,
+1310721,2,2,28,1,6,1,10,28,34,63,38,3,26,1600751,16,
+1310721,2,3,26,2,1600803,14,1310721,2,3,26,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1600665,14,3,1,10,28,1600803,14,
+1,1310721,2,5,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,
+1835009,40,1600851,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,
+4,1310721,2,2,1310721,2,3,26,2,26,1310721,2,5,26,4,1310721,
+2,2,1310721,2,5,26,2,40,1601297,16,1542657,1310721,2,2,26,2,
+-3,28,1,6,1,10,28,34,63,38,3,26,1601245,16,1310721,2,
+7,26,1542657,1310721,2,2,3,26,26,2,1587809,12,10,3,6,10,
+4,8,1310721,2,7,26,2,1,40,1601055,16,1310721,2,7,26,1542657,
+1310721,2,2,3,26,26,2,1589617,12,10,3,6,10,4,8,1417729,
+1310721,2,7,26,2,26,2,3,28,1,6,1,10,28,34,63,
+38,3,26,1601119,16,1310721,2,7,26,2,1589741,12,8,1601215,14,1417729,
+1310721,2,7,26,2,26,2,13,28,1,6,1,10,28,34,63,
+38,3,26,1601193,16,45,1425921,1310721,2,7,26,2,26,2,26,1589235,
+12,8,1601215,14,1425921,1310721,2,7,26,2,26,2,1589149,12,8,1310721,
+2,1310721,2,2,5,26,10,3,6,10,4,8,1601293,14,1542657,1310721,
+2,2,26,2,1588955,12,8,1310721,2,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1600895,14,1,1601305,14,1,1310721,2,9,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1601353,16,1966081,
+1310721,4,1579069,12,1310721,2,4,1,1310721,2,3,26,4,1310721,2,3,
+26,2,1582523,2,40,1601483,16,1547777,1310721,2,3,26,2,26,2,1310721,
+2,2,28,1,6,1,10,28,34,63,38,3,26,1601445,16,1,
+1601545,14,1310721,2,3,26,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1601371,14,1547777,1582523,2,26,1310721,2,2,10,3,6,10,
+4,8,1582523,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1,1601545,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,1310721,
+4,1310721,2,1835009,40,1601593,16,1966081,1310721,4,1579069,12,1310721,2,4,1582517,
+2,1310721,2,3,26,4,1310721,2,3,26,2,1601727,16,1310721,2,3,
+26,1,6,2,1,6,-1,26,5,6,4,10,8,8,1546753,1310721,
+2,3,26,2,26,2,1310721,2,2,28,1,6,1,10,28,34,
+63,38,3,26,1601723,16,1310721,2,3,26,2,1601741,14,1601613,14,3,
+1,10,28,1601741,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1601789,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1582519,2,1310721,2,3,26,4,1310721,2,3,26,2,1601923,16,1310721,
+2,3,26,1,6,2,1,6,-1,26,5,6,4,10,8,8,
+1547265,1310721,2,3,26,2,26,2,1310721,2,2,28,1,6,1,10,
+28,34,63,38,3,26,1601919,16,1310721,2,3,26,2,1601937,14,1601809,
+14,3,1,10,28,1601937,14,1,1310721,2,5,26,1310721,4,18,1310721,
+2,5,28,1310721,4,1310721,2,1835009,40,1601985,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1582521,2,1310721,2,3,26,4,1310721,2,3,26,2,1602119,
+16,1310721,2,3,26,1,6,2,1,6,-1,26,5,6,4,10,
+8,8,1547457,1310721,2,3,26,2,26,2,1310721,2,2,28,1,6,
+1,10,28,34,63,38,3,26,1602115,16,1310721,2,3,26,2,1602133,
+14,1602005,14,3,1,10,28,1602133,14,1,1310721,2,5,26,1310721,4,
+18,1310721,2,15,28,1310721,4,1310721,2,1835009,40,1602181,16,1966081,1310721,4,
+1579069,12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,1310721,
+2,2,1586793,12,1310721,2,7,26,4,1310721,2,7,26,2,1601559,12,
+1310721,2,9,26,4,1310721,2,9,26,2,1,40,1602321,16,1310721,2,
+9,26,1582517,2,10,3,6,10,4,8,1582517,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1546753,1310721,2,9,26,2,26,1310721,
+2,7,26,2,10,3,6,10,4,8,1546881,1310721,2,9,26,2,
+26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,2,3,26,
+2,1,40,1602545,16,1546881,1310721,2,9,26,2,26,1,1310721,2,3,
+26,2,28,10,3,6,10,4,8,1547137,1310721,2,9,26,2,26,
+1310721,2,3,26,2,10,3,6,10,4,8,1547009,1310721,2,9,26,
+2,26,1,10,3,6,10,4,8,1310721,2,7,26,2,1601319,12,
+8,1310721,2,9,26,2,1603173,14,1547009,1310721,2,9,26,2,26,1310721,
+2,5,26,2,1599475,12,10,3,6,10,4,8,1547137,1310721,2,9,
+26,2,26,1582525,2,1547009,1310721,2,9,26,2,26,2,28,10,3,
+6,10,4,8,1310721,2,7,26,2,1601319,12,8,1310721,2,13,26,
+1310721,2,2,1573885,12,10,3,6,10,4,8,1582599,2001,26,1310721,2,
+2,1310721,2,13,26,2,1574337,12,8,1582599,2001,1310721,2,13,26,2,
+26,26,123,10,3,6,10,4,8,1582599,2003,1310721,2,13,26,2,
+26,26,1,10,3,6,10,4,8,1310721,2,11,26,1582599,2001,26,
+1586793,12,10,3,6,10,4,8,1310721,2,3,26,2,17,40,3,
+36,1602829,16,3,1602885,14,1310721,2,3,26,2,11,28,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1602895,16,3,1602951,14,1310721,2,3,26,2,9,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1602961,16,3,1603017,14,1310721,2,3,26,2,7,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1603157,16,1310721,2,11,26,2,1601951,12,1,40,1603101,
+16,1547457,1582521,2,26,1310721,2,11,26,2,10,3,6,10,4,8,
+1582521,1,6,2,1,6,3,26,5,6,4,10,8,8,1547585,1310721,
+2,11,26,2,1601951,12,26,1310721,2,9,26,2,10,3,6,10,
+4,8,1310721,2,11,26,2,1601319,12,8,1310721,2,9,26,2,1603173,
+14,1,1310721,2,15,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,
+2,1835009,40,1603221,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,
+2,4,1310721,2,2,1586793,12,1310721,2,5,26,4,1310721,2,5,26,
+2,1601755,12,1310721,2,7,26,4,1310721,2,7,26,2,1,40,1603351,
+16,1310721,2,7,26,1582519,2,10,3,6,10,4,8,1582519,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1547265,1310721,2,7,26,
+2,26,1310721,2,5,26,2,10,3,6,10,4,8,1547329,1310721,2,
+7,26,2,26,1310721,2,3,26,2,1599475,12,10,3,6,10,4,
+8,1547393,1310721,2,7,26,2,26,1582525,2,1547329,1310721,2,7,26,2,
+26,2,28,10,3,6,10,4,8,1310721,2,5,26,2,1601319,12,
+8,1310721,2,7,26,2,1603507,14,1,1310721,2,9,26,1310721,4,18,
+1310721,2,9,28,1310721,4,1310721,2,1835009,40,1603555,16,1966081,1310721,4,1579069,
+12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,1310721,2,
+2,1586793,12,11,1310721,2,3,26,2,1587311,12,1310721,2,7,26,4,
+1442305,1310721,2,7,26,2,26,3,1310721,2,5,26,2,34,10,3,
+6,10,4,8,1310721,2,7,26,2,1603673,14,1,1310721,2,9,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1603721,16,1966081,
+1310721,4,1579069,12,1310721,2,4,1584845,2,1310721,2,3,26,4,1310721,2,
+3,26,2,1584847,2,10,40,1603863,16,1310721,2,3,26,1,6,2,
+1,6,-1,26,5,6,4,10,8,8,1466881,1310721,2,3,26,2,
+26,2,1310721,2,2,28,1,6,1,10,28,34,63,38,3,26,
+1603859,16,1310721,2,3,26,2,1603877,14,1603741,14,3,1,10,28,1603877,
+14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1603925,16,1966081,1310721,4,1579069,12,1310721,2,4,1584845,2,1310721,
+2,3,26,4,1584845,2,1025,40,3,36,1604005,16,1603997,14,116,111,
+111,32,109,97,110,121,32,108,111,99,97,108,115,0,1603965,1585585,
+12,8,1584845,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1466881,1310721,2,3,26,2,26,1310721,2,2,10,3,6,10,4,8,
+1467905,1310721,2,3,26,2,26,1584851,2,10,3,6,10,4,8,1468929,
+1310721,2,3,26,2,26,1584849,2,10,3,6,10,4,8,1469953,1310721,
+2,3,26,2,26,1,10,3,6,10,4,8,1470977,1310721,2,3,
+26,2,26,1,10,3,6,10,4,8,1472001,1310721,2,3,26,2,
+26,1,10,3,6,10,4,8,1473025,1310721,2,3,26,2,26,1,
+10,3,6,10,4,8,1474049,1310721,2,3,26,2,26,1,10,3,
+6,10,4,8,1556993,1310721,2,3,26,2,26,1584975,2,10,3,6,
+10,4,8,1558017,1310721,2,3,26,2,26,1,10,3,6,10,4,
+8,1310721,2,3,26,2,1604339,14,1,1310721,2,5,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1604387,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1469953,1310721,2,2,26,2,11,28,1,6,1,10,
+28,34,63,38,3,26,1604465,16,1310721,2,1470977,1310721,2,2,26,2,
+10,3,6,10,4,8,1604393,14,1310721,2,2,1604477,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1604525,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1469953,1310721,2,2,26,2,1,
+28,1,6,1,10,28,34,63,38,1,10,28,1604575,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,
+1604623,16,1966081,1310721,4,1579069,12,1310721,2,4,1472001,1310721,2,2,26,3,
+10,3,6,10,4,8,1584853,2,1,6,1,10,28,34,63,38,
+3,26,1604687,16,1,1605063,14,1310721,2,3,26,1310721,2,2,1604353,12,
+10,3,6,10,4,8,1472001,1310721,2,3,26,2,26,3,10,3,
+6,10,4,8,1469953,1310721,2,3,26,2,26,2,9,28,1,6,
+1,10,28,34,63,38,3,26,1604871,16,1310721,2,2,1604857,14,117,
+115,101,100,32,97,102,116,101,114,32,105,116,32,119,97,115,
+32,103,105,118,101,110,32,97,119,97,121,0,1604799,1586469,12,8,
+1,1605063,14,1469953,1310721,2,3,26,2,26,2,7,28,1,6,1,
+10,28,34,63,38,3,26,1604963,16,1468929,1310721,2,3,26,2,26,
+2,1584849,2,40,1,6,1,10,28,34,63,38,1,10,28,1604965,
+14,1,1605055,16,1468929,1310721,2,3,26,2,26,1584849,2,10,3,6,
+10,4,8,1469953,1310721,2,3,26,2,26,3,10,3,6,10,4,
+8,1474049,1310721,2,3,26,2,26,3,10,3,6,10,4,8,1,
+1605063,14,1,1310721,2,5,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1605111,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,
+2,3,28,1,6,1,10,28,34,63,38,3,26,1605301,16,1605293,
+14,97,32,110,101,119,32,111,98,106,101,99,116,32,99,97,
+110,39,116,32,98,101,32,117,115,101,100,32,97,115,32,97,
+32,112,108,97,105,110,32,118,97,108,117,101,59,32,98,105,
+110,100,32,105,116,32,116,111,32,97,32,110,97,109,101,32,
+102,105,114,115,116,0,1605155,1586351,12,8,1310721,2,2,5,40,3,
+36,1605335,16,1310721,2,2,5,28,1604589,12,8,1,1605343,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,
+1605391,16,1966081,1310721,4,1579069,12,1310721,2,4,1467905,1310721,2,2,26,2,
+1590069,12,8,3,1589235,12,8,1584959,2,1589915,12,8,9,1589235,12,8,
+1,1605449,14,1,1310721,2,3,26,1310721,4,18,1310721,2,9,28,1310721,
+4,1310721,2,1835009,40,1605497,16,1966081,1310721,4,1579069,12,1310721,2,3,26,
+4,1310721,2,4,1584845,2,1310721,2,5,26,4,1584853,2,1,6,1,
+10,28,34,63,38,3,26,1605561,16,3,1605607,14,1584857,2,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1605617,16,1,1606177,14,1310721,2,5,26,2,1584847,2,10,
+40,1606169,16,1310721,2,5,26,1,6,2,1,6,-1,26,5,6,
+4,10,8,8,1468929,1310721,2,5,26,2,26,2,1310721,2,2,40,
+1605705,16,1605617,14,1310721,2,7,26,1469953,1310721,2,5,26,2,26,2,
+10,3,6,10,4,8,1310721,2,7,26,2,3,28,1,6,1,
+10,28,34,63,38,3,26,1605799,16,1310721,2,5,26,2,1605357,12,
+8,1606165,14,1310721,2,7,26,2,5,28,1,6,1,10,28,34,
+63,38,3,26,1606045,16,1310721,2,5,26,2,1606033,14,117,32,111,
+98,106,101,99,116,32,109,117,115,116,32,108,101,97,118,101,
+32,116,104,105,115,32,98,108,111,99,107,32,40,98,108,111,
+99,107,32,118,97,108,117,101,44,32,97,115,115,105,103,110,
+109,101,110,116,32,116,111,32,116,104,101,32,101,110,99,108,
+111,115,105,110,103,32,98,108,111,99,107,44,32,111,114,32,
+114,101,116,117,114,110,41,0,1605851,1586469,12,8,1606165,14,1310721,2,
+7,26,2,7,28,1,6,1,10,28,34,63,38,3,26,1606165,
+16,1310721,2,5,26,2,1606157,14,100,32,111,98,106,101,99,116,
+32,119,97,115,32,110,101,118,101,114,32,103,105,118,101,110,
+32,97,119,97,121,0,1606097,1586469,12,8,1605617,14,1,1606177,14,1,
+1310721,2,9,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1606225,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1584845,2,
+40,1606467,16,1584853,2,1606293,16,1474049,1310721,2,2,26,2,1,6,1,
+10,28,34,63,38,1,10,28,1606295,14,1,1606357,16,1472001,1310721,2,
+2,26,2,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1606359,14,1,1606433,16,1466881,1310721,2,
+2,26,2,1606425,14,109,32,111,98,106,101,99,116,32,105,115,
+32,110,101,118,101,114,32,117,115,101,100,0,1606379,1585849,12,8,
+1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,1606231,
+14,1,1606475,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,
+1310721,4,1310721,2,1835009,40,1606523,16,1966081,1310721,4,1579069,12,1310721,2,4,
+1584847,2,1310721,2,3,26,4,1310721,2,2,1606191,12,8,1584849,2,3,
+1605463,12,8,1310721,2,3,26,2,1310721,2,2,40,1606719,16,1468929,1310721,
+2,3,26,2,26,2,1584849,2,40,3,36,1606681,16,1469953,1310721,2,
+3,26,2,26,9,10,3,6,10,4,8,1468929,1310721,2,3,26,
+2,26,1584849,2,3,28,10,3,6,10,4,8,1310721,2,3,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1606567,14,1584845,
+1310721,2,2,10,3,6,10,4,8,1,1606747,14,1,1310721,2,5,
+26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1606795,16,
+1966081,1310721,4,1579069,12,1584873,2,1310721,2,4,1584847,2,1310721,2,3,26,
+4,1310721,2,5,26,1507841,1310721,2,2,26,10,3,6,10,4,8,
+1310721,2,5,26,2,1,26,1584847,2,10,3,6,10,4,8,1310721,
+2,5,26,2,3,26,1584845,2,10,3,6,10,4,8,1310721,2,
+5,26,1310721,2,5,26,2,5,26,10,3,6,10,4,8,1310721,
+2,3,26,2,1584845,2,40,1607161,16,1310721,2,5,26,2,1,26,
+1469953,1310721,2,3,26,2,26,2,10,3,6,10,4,8,1310721,2,
+5,26,2,3,26,1470977,1310721,2,3,26,2,26,2,10,3,6,
+10,4,8,1310721,2,5,26,2,5,26,1468929,1310721,2,3,26,2,
+26,2,10,3,6,10,4,8,1310721,2,5,26,1310721,2,5,26,
+2,7,26,10,3,6,10,4,8,1310721,2,3,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1606943,14,1584873,1310721,2,5,
+26,2,1507841,28,10,3,6,10,4,8,1584873,2,16001,40,3,36,
+1607285,16,1607277,14,110,101,115,116,105,110,103,32,116,111,111,32,
+100,101,101,112,32,102,111,114,32,116,104,101,32,97,110,97,
+108,121,122,101,114,0,1607209,1585585,12,8,1310721,2,2,1607297,14,1,
+1310721,2,7,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1607345,16,1966081,1310721,4,1579069,12,1310721,2,4,1584873,1310721,2,2,10,
+3,6,10,4,8,1,1607379,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,9,28,1310721,4,1310721,2,1835009,40,1607427,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1507841,1310721,2,2,26,1310721,2,3,26,4,1310721,2,
+3,26,2,1,26,2,1310721,2,5,26,4,1310721,2,3,26,2,
+3,26,2,1310721,2,7,26,4,1310721,2,7,26,2,1584845,2,10,
+40,1607551,16,1310721,2,7,26,1584845,2,10,3,6,10,4,8,1310721,
+2,3,26,1310721,2,3,26,2,5,26,10,3,6,10,4,8,
+1310721,2,5,26,2,1310721,2,7,26,2,40,1607809,16,1469953,1310721,2,
+5,26,2,26,1310721,2,3,26,2,1,26,2,10,3,6,10,
+4,8,1470977,1310721,2,5,26,2,26,1310721,2,3,26,2,3,26,
+2,10,3,6,10,4,8,1468929,1310721,2,5,26,2,26,1310721,2,
+3,26,2,5,26,2,10,3,6,10,4,8,1310721,2,3,26,
+1310721,2,3,26,2,7,26,10,3,6,10,4,8,1310721,2,5,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1607585,14,
+1,1607817,14,1,1310721,2,9,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1607865,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,
+2,2,1,28,1,6,1,10,28,34,63,38,3,26,1607911,16,
+3,1607963,14,1310721,2,2,9,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1607969,14,1,
+1310721,2,3,26,1310721,4,18,1310721,2,11,28,1310721,4,1310721,2,1835009,
+40,1608017,16,1966081,1310721,4,1579069,12,1310721,2,4,1507841,1310721,2,2,26,
+1310721,2,3,26,4,1310721,2,3,26,2,1,26,2,1310721,2,5,
+26,4,1310721,2,3,26,2,3,26,2,1310721,2,7,26,4,1310721,
+2,7,26,2,1584845,2,10,40,1608141,16,1310721,2,7,26,1584845,2,
+10,3,6,10,4,8,1310721,2,3,26,1310721,2,3,26,2,5,
+26,10,3,6,10,4,8,1310721,2,5,26,2,1310721,2,7,26,
+2,40,1608765,16,1310721,2,9,26,1469953,1310721,2,5,26,2,26,2,
+10,3,6,10,4,8,1310721,2,9,26,2,1607831,12,1608301,16,1310721,
+2,3,26,2,1,26,2,1607831,12,1,6,1,10,28,34,63,
+38,1,10,28,1608303,14,1,1608383,16,1310721,2,3,26,2,1,26,
+2,9,28,1,6,1,10,28,34,63,38,3,26,1608379,16,1469953,
+1310721,2,5,26,2,26,9,10,3,6,10,4,8,1608693,14,1310721,
+2,9,26,2,1310721,2,3,26,2,1,26,2,28,1,6,1,
+10,28,34,63,38,1,10,28,1608443,16,3,1608521,14,1468929,1310721,2,
+5,26,2,26,2,1310721,2,3,26,2,5,26,2,28,1,6,
+1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,63,
+38,1,10,28,1608531,16,3,1608675,14,1310721,2,9,26,2,11,28,
+1,6,1,10,28,34,63,38,3,26,1608651,16,1470977,1310721,2,5,
+26,2,26,2,1310721,2,3,26,2,3,26,2,28,1,6,1,
+10,28,34,63,38,1,10,28,1,6,1,10,28,34,63,38,
+1,10,28,1608653,14,1,1,6,1,10,28,34,63,38,1,10,
+28,1608693,16,1310721,2,5,26,2,1608779,14,1310721,2,3,26,1310721,2,
+3,26,2,7,26,10,3,6,10,4,8,1310721,2,5,26,1,
+6,2,1,6,3,26,5,6,4,10,8,8,1608175,14,3,1,
+10,28,1608779,14,1,1310721,2,11,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1608827,16,1966081,1310721,4,1579069,12,1310721,2,4,
+1310721,2,2,1,28,1,6,1,10,28,34,63,38,3,26,1608889,
+16,1608883,14,101,109,112,116,121,0,1608871,1609215,14,1310721,2,2,3,
+28,1,6,1,10,28,34,63,38,3,26,1608937,16,1608931,14,109,
+0,1608927,1609215,14,1310721,2,2,5,28,1,6,1,10,28,34,63,
+38,3,26,1608985,16,1608979,14,117,0,1608975,1609215,14,1310721,2,2,7,
+28,1,6,1,10,28,34,63,38,3,26,1609033,16,1609027,14,100,
+0,1609023,1609215,14,1310721,2,2,9,28,1,6,1,10,28,34,63,
+38,3,26,1609099,16,1609093,14,103,105,118,101,110,32,97,119,97,
+121,0,1609071,1609215,14,1310721,2,2,11,28,1,6,1,10,28,34,
+63,38,3,26,1609185,16,1609179,14,111,119,110,101,100,32,98,121,
+32,97,32,99,111,110,116,97,105,110,101,114,0,1609137,1609215,14,
+1609207,14,98,111,114,114,111,119,101,100,0,1609189,1609215,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,
+1609263,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,1310721,2,3,26,
+4,1310721,2,4,1584853,2,1,6,1,10,28,34,63,38,3,26,
+1609323,16,3,1609349,14,1585091,2,1,6,1,10,28,34,63,38,1,
+10,28,1609359,16,3,1609385,14,1584991,2,1,6,1,10,28,34,63,
+38,1,10,28,1609395,16,1,1609615,14,1585093,12,8,1466881,1310721,2,2,
+26,2,1573341,12,8,1609429,14,58,32,0,1609423,1573341,12,8,1310721,2,
+5,26,2,1573341,12,8,1609501,14,32,40,111,110,101,32,112,97,
+116,104,32,108,101,97,118,101,115,32,105,116,32,0,1609457,1573341,
+12,8,1310721,2,3,26,2,1608793,12,1573341,12,8,1609555,14,44,32,
+97,110,111,116,104,101,114,32,0,1609533,1573341,12,8,1469953,1310721,2,
+2,26,2,1608793,12,1573341,12,8,1609593,14,41,0,1609589,1573341,12,8,
+1585237,12,8,1,1609615,14,1,1310721,2,7,26,1310721,4,18,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1310721,2,5,28,1310721,4,1310721,2,1835009,40,1609795,16,1966081,1310721,4,1579069,
+12,1310721,2,3,26,4,1310721,2,4,1310721,2,3,26,2,1310721,2,
+2,3,26,2,40,3,36,1609849,16,1,1609897,14,1310721,2,2,5,
+7,1310721,2,3,26,2,1310721,2,2,1,26,2,28,30,26,26,
+2,1609897,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,1310721,
+4,1310721,2,1835009,40,1609945,16,1966081,1310721,4,1579069,12,1310721,2,3,26,
+4,1310721,2,4,1310721,2,2,7,7,1310721,2,3,26,2,1310721,2,
+2,1,26,2,28,30,26,26,2,1610009,14,1,1310721,2,5,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1610057,16,1966081,
+1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,9,
+7,1310721,2,3,26,2,1310721,2,2,1,26,2,28,30,26,26,
+2,1610121,14,1,1310721,2,5,26,1310721,4,18,1310721,2,9,28,1310721,
+4,1310721,2,1835009,40,1610169,16,1966081,1310721,4,1579069,12,1310721,2,4,1567233,
+1609629,2,26,1310721,2,3,26,4,1584847,2,1310721,2,5,26,4,1609629,
+2,7,26,7,1584845,2,1584847,2,28,30,26,1572353,1567233,28,40,3,
+36,1610325,16,1610317,14,116,111,111,32,109,97,110,121,32,98,114,
+101,97,107,115,32,102,111,114,32,116,104,101,32,97,110,97,
+108,121,122,101,114,0,1610251,1585585,12,8,1310721,2,3,26,2,1,
+26,1310721,2,2,10,3,6,10,4,8,1310721,2,3,26,2,3,
+26,1584847,2,10,3,6,10,4,8,1310721,2,3,26,2,5,26,
+1584845,2,10,3,6,10,4,8,1310721,2,7,26,1310721,2,3,26,
+2,7,26,10,3,6,10,4,8,1310721,2,5,26,2,1584845,2,
+40,1610669,16,1310721,2,7,26,2,1,26,1469953,1310721,2,5,26,2,
+26,2,10,3,6,10,4,8,1310721,2,7,26,2,3,26,1470977,
+1310721,2,5,26,2,26,2,10,3,6,10,4,8,1310721,2,7,
+26,2,5,26,1468929,1310721,2,5,26,2,26,2,10,3,6,10,
+4,8,1310721,2,7,26,1310721,2,7,26,2,7,26,10,3,6,
+10,4,8,1310721,2,5,26,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1610451,14,1609629,1310721,2,7,26,2,1567233,28,10,3,
+6,10,4,8,1310721,2,3,26,2,1610713,14,1,1310721,2,9,26,
+1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1610761,16,1966081,
+1310721,4,1579069,12,1310721,2,4,1609759,2,129,40,3,36,1610859,16,1610851,
+14,116,111,111,32,109,97,110,121,32,112,97,116,104,115,32,
+102,111,114,32,116,104,101,32,97,110,97,108,121,122,101,114,
+0,1610787,1585585,12,8,1609631,1609759,2,26,1310721,2,2,10,3,6,10,
+4,8,1609759,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1,1610921,14,1,1310721,2,3,26,1310721,4,18,1310721,2,11,28,1310721,
+4,1310721,2,1835009,40,1610969,16,1966081,1310721,4,1579069,12,1310721,2,5,26,
+4,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1310721,2,5,26,
+2,1609761,12,1310721,2,7,26,4,1310721,2,3,26,2,1310721,2,5,
+26,2,1609761,12,1310721,2,9,26,4,1310721,2,7,26,2,1607831,12,
+1611117,16,1310721,2,9,26,2,1607831,12,1,6,1,10,28,34,63,
+38,1,10,28,1611119,14,1,1611129,16,3,1611441,14,1310721,2,7,26,
+2,1310721,2,9,26,2,28,1,6,1,10,28,34,63,38,3,
+26,1611267,16,1310721,2,2,1310721,2,5,26,2,1610023,12,1310721,2,3,
+26,2,1310721,2,5,26,2,1610023,12,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1611269,
+14,1,1611433,16,1310721,2,7,26,2,11,28,1,6,1,10,28,
+34,63,38,1,10,28,1611319,16,3,1611407,14,1310721,2,2,1310721,2,
+5,26,2,1609911,12,1310721,2,3,26,2,1310721,2,5,26,2,1609911,
+12,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,
+10,28,1611435,14,1,1611441,14,1,1310721,2,11,26,1310721,4,18,1310721,
+2,21,28,1310721,4,1310721,2,1835009,40,1611489,16,1966081,1310721,4,1579069,12,
+1310721,2,3,26,4,1310721,2,4,1584847,2,1310721,2,5,26,4,1609759,
+2,1,6,1,10,28,34,63,38,3,26,1611553,16,1,1613025,14,
+1310721,2,5,26,2,1310721,2,2,40,1613017,16,1310721,2,9,26,1609631,
+1,26,2,10,3,6,10,4,8,1310721,2,13,26,1310721,2,9,
+26,2,1310721,2,5,26,2,1609761,12,10,3,6,10,4,8,1310721,
+2,15,26,1,10,3,6,10,4,8,1310721,2,17,26,3,10,
+3,6,10,4,8,1310721,2,19,26,3,1,10,28,10,3,6,
+10,4,8,1310721,2,7,26,1,10,3,6,10,4,8,1310721,2,
+7,26,2,1609759,2,40,1612195,16,1310721,2,11,26,1609631,1310721,2,7,
+26,2,26,2,1310721,2,5,26,2,1609761,12,10,3,6,10,4,
+8,1310721,2,11,26,2,9,28,1,6,1,10,28,34,63,38,
+3,26,1611855,16,3,1611911,14,1310721,2,11,26,2,7,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1611937,16,1310721,2,15,26,3,10,3,6,10,4,8,
+1310721,2,11,26,2,5,28,1,6,1,10,28,34,63,38,3,
+26,1611981,16,3,1612037,14,1310721,2,11,26,2,13,28,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1612063,16,1310721,2,17,26,1,10,3,6,10,4,8,1310721,
+2,9,26,2,1609631,1310721,2,7,26,2,26,2,1310721,2,5,26,
+2,1610935,12,1,6,1,10,28,34,63,38,3,26,1612157,16,1310721,
+2,19,26,1310721,2,7,26,2,10,3,6,10,4,8,1310721,2,
+7,26,1,6,2,1,6,3,26,5,6,4,10,8,8,1611741,
+14,1469953,1310721,2,5,26,2,26,1310721,2,13,26,2,10,3,6,
+10,4,8,1470977,1310721,2,5,26,2,26,1310721,2,9,26,2,1310721,
+2,5,26,2,1609911,12,10,3,6,10,4,8,1468929,1310721,2,5,
+26,2,26,1310721,2,9,26,2,1310721,2,5,26,2,1610023,12,10,
+3,6,10,4,8,1310721,2,19,26,2,1,40,1612537,16,1310721,2,
+13,26,2,1607831,12,1612533,16,1310721,2,7,26,1,10,3,6,10,
+4,8,1310721,2,7,26,2,1609759,2,40,1612533,16,1609631,1310721,2,7,
+26,2,26,2,1310721,2,5,26,2,1609761,12,9,28,1,6,1,
+10,28,34,63,38,3,26,1612495,16,1469953,1310721,2,5,26,2,26,
+9,10,3,6,10,4,8,1310721,2,7,26,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1612389,14,1612979,14,1310721,2,15,26,
+2,1612587,16,1310721,2,17,26,2,1,6,1,10,28,34,63,38,
+1,10,28,1612589,14,1,1612625,16,1469953,1310721,2,5,26,2,26,9,
+10,3,6,10,4,8,1612979,14,1584853,2,1612683,16,1585091,2,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1612685,14,1,1612739,16,1584991,2,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1612741,
+14,1,1612979,16,1585093,12,8,1466881,1310721,2,5,26,2,26,2,1573341,
+12,8,1612783,14,58,32,0,1612777,1573341,12,8,1310721,2,3,26,2,
+1573341,12,8,1612855,14,32,40,111,110,101,32,112,97,116,104,32,
+108,101,97,118,101,115,32,105,116,32,0,1612811,1573341,12,8,1310721,
+2,13,26,2,1608793,12,1573341,12,8,1612909,14,44,32,97,110,111,
+116,104,101,114,32,0,1612887,1573341,12,8,1609631,1310721,2,19,26,2,
+26,2,1310721,2,5,26,2,1609761,12,1608793,12,1573341,12,8,1612965,14,
+41,0,1612961,1573341,12,8,1585237,12,8,1310721,2,5,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1611553,14,1,1613025,14,1,
+1310721,2,21,26,1310721,4,18,1310721,2,13,28,1310721,4,1310721,2,1835009,
+40,1613073,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,1310721,2,3,
+26,4,1310721,2,4,1584847,2,1310721,2,7,26,4,1,1310721,2,9,
+26,4,1584853,2,1,6,1,10,28,34,63,38,3,26,1613159,16,
+1,1613519,14,1310721,2,7,26,2,1310721,2,3,26,2,40,1613503,16,
+1310721,2,11,26,1310721,2,2,1310721,2,7,26,2,1609761,12,10,3,
+6,10,4,8,1469953,1310721,2,7,26,2,26,2,9,28,1,6,
+1,10,28,34,63,38,3,26,1613395,16,1310721,2,11,26,2,3,
+28,1,6,1,10,28,34,63,38,3,26,1613313,16,3,1613369,14,
+1310721,2,11,26,2,7,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1,6,1,10,
+28,34,63,38,1,10,28,1613397,14,1,1613465,16,1310721,2,9,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1310721,2,5,
+26,2,1613465,16,1310721,2,7,26,2,1605357,12,8,1310721,2,7,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1613159,14,1310721,
+2,9,26,2,1613519,14,1,1310721,2,13,26,1310721,4,18,1310721,2,
+11,28,1310721,4,1310721,2,1835009,40,1613567,16,1966081,1310721,4,1579069,12,1310721,
+2,4,1507841,1310721,2,2,26,1310721,2,3,26,4,1310721,2,3,26,
+2,1,26,2,1310721,2,5,26,4,1310721,2,3,26,2,3,26,
+2,1310721,2,7,26,4,1584853,2,1,6,1,10,28,34,63,38,
+3,26,1613679,16,3,1613725,14,1584857,2,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1613735,16,
+1,1615101,14,1310721,2,7,26,2,1584845,2,10,40,1613781,16,1310721,2,
+7,26,1584845,2,10,3,6,10,4,8,1310721,2,5,26,2,1310721,
+2,7,26,2,40,1615093,16,1310721,2,9,26,1469953,1310721,2,5,26,
+2,26,2,10,3,6,10,4,8,1310721,2,9,26,2,1607831,12,
+1613915,16,1310721,2,3,26,2,1310721,2,5,26,2,1609761,12,1607831,12,
+1,6,1,10,28,34,63,38,1,10,28,1613917,14,1,1614005,16,
+1310721,2,3,26,2,1310721,2,5,26,2,1609761,12,9,28,1,6,
+1,10,28,34,63,38,3,26,1614001,16,1469953,1310721,2,5,26,2,
+26,9,10,3,6,10,4,8,1615055,14,1310721,2,9,26,2,1310721,
+2,3,26,2,1310721,2,5,26,2,1609761,12,28,1,6,1,10,
+28,34,63,38,1,10,28,1614073,16,3,1614159,14,1468929,1310721,2,5,
+26,2,26,2,1310721,2,3,26,2,1310721,2,5,26,2,1610023,12,
+28,1,6,1,10,28,34,63,38,1,10,28,1,6,1,10,
+28,34,63,38,1,10,28,1614169,16,3,1614321,14,1310721,2,9,26,
+2,11,28,1,6,1,10,28,34,63,38,3,26,1614297,16,1470977,
+1310721,2,5,26,2,26,2,1310721,2,3,26,2,1310721,2,5,26,
+2,1609911,12,28,1,6,1,10,28,34,63,38,1,10,28,1,
+6,1,10,28,34,63,38,1,10,28,1614299,14,1,1,6,1,
+10,28,34,63,38,1,10,28,1615055,16,1310721,2,9,26,2,9,
+28,1,6,1,10,28,34,63,38,3,26,1614369,16,3,1614425,14,
+1310721,2,9,26,2,7,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1614659,16,1310721,2,
+5,26,2,1614647,14,105,115,32,103,105,118,101,110,32,97,119,
+97,121,32,105,110,115,105,100,101,32,97,32,108,111,111,112,
+32,116,104,97,116,32,99,111,109,101,115,32,98,97,99,107,
+32,97,114,111,117,110,100,32,116,111,32,105,116,59,32,103,
+105,118,101,32,105,116,32,97,119,97,121,32,111,110,32,97,
+32,112,97,116,104,32,116,104,97,116,32,108,101,97,118,101,
+115,32,116,104,101,32,108,111,111,112,0,1614443,1586469,12,8,1615055,
+14,1585091,2,1,6,1,10,28,34,63,38,3,26,1614737,16,1584991,
+2,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1614739,14,1,1615055,16,1585093,12,8,1466881,1310721,
+2,5,26,2,26,2,1573341,12,8,1614949,14,58,32,99,104,97,
+110,103,101,115,32,115,116,97,116,101,32,105,110,115,105,100,
+101,32,97,32,108,111,111,112,59,32,101,97,99,104,32,112,
+97,115,115,32,104,97,115,32,116,111,32,108,101,97,118,101,
+32,105,116,32,97,115,32,105,116,32,102,111,117,110,100,32,
+105,116,32,40,105,116,32,119,101,110,116,32,102,114,111,109,
+32,0,1614775,1573341,12,8,1310721,2,3,26,2,1310721,2,5,26,2,
+1609761,12,1608793,12,1573341,12,8,1615005,14,32,116,111,32,0,1614995,1573341,
+12,8,1310721,2,9,26,2,1608793,12,1573341,12,8,1615041,14,41,0,
+1615037,1573341,12,8,1585237,12,8,1310721,2,5,26,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1613781,14,1,1615101,14,1,1310721,2,
+11,26,1310721,4,18,1310721,2,19,28,1310721,4,1310721,2,1835009,40,1615149,
+16,1966081,1310721,4,1579069,12,1310721,2,11,26,4,1310721,2,9,26,4,
+1310721,2,7,26,4,1310721,2,5,26,4,1310721,2,3,26,4,1310721,
+2,4,1310721,2,13,26,1606761,12,10,3,6,10,4,8,1609759,1,
+10,3,6,10,4,8,1310721,2,3,26,2,1615275,16,1507841,1310721,2,
+2,26,1610727,12,8,1310721,2,7,26,2,1615309,16,1507841,1310721,2,13,
+26,2,26,1610727,12,8,1310721,2,9,26,2,1310721,2,11,26,2,
+1611455,12,8,1310721,2,7,26,2,1615381,16,1507841,1310721,2,13,26,2,
+26,1310721,2,9,26,2,3,1613039,12,8,1310721,2,15,26,1,10,
+3,6,10,4,8,1310721,2,3,26,2,1615463,16,1310721,2,15,26,
+1507841,1310721,2,2,26,1310721,2,9,26,2,1,1613039,12,10,3,6,
+10,4,8,1310721,2,15,26,2,1615581,16,1310721,2,17,26,1589535,12,
+10,3,6,10,4,8,15,1589235,12,8,1310721,2,5,26,2,1584837,
+2,1589317,12,8,1507841,1310721,2,2,26,1310721,2,9,26,2,3,1613039,
+12,8,1310721,2,17,26,2,1584837,2,1589317,12,8,1615601,14,1310721,2,
+5,26,2,1584837,2,1589317,12,8,1584857,1310721,2,3,26,2,1615623,16,
+3,1615655,14,1310721,2,7,26,2,1,6,1,10,28,34,63,38,
+1,10,28,10,3,6,10,4,8,1,1615675,14,1,1310721,2,19,
+26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1615723,16,
+1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1584853,2,1,
+6,1,10,28,34,63,38,3,26,1615777,16,1310721,2,2,1616747,14,
+1310721,2,2,5,40,1615893,16,1615875,14,111,110,108,121,32,97,32,
+110,97,109,101,100,32,111,119,110,101,100,32,111,98,106,101,
+99,116,32,99,97,110,32,98,101,32,114,101,99,97,115,116,
+0,1615795,1586351,12,8,1310721,2,2,1616747,14,1310721,2,5,26,1310721,2,
+2,5,28,10,3,6,10,4,8,1310721,2,7,26,1469953,1310721,2,
+5,26,2,26,2,10,3,6,10,4,8,1472001,1310721,2,5,26,
+2,26,3,10,3,6,10,4,8,1310721,2,7,26,2,11,28,
+1,6,1,10,28,34,63,38,3,26,1616157,16,1310721,2,5,26,
+2,1616145,14,98,101,108,111,110,103,115,32,116,111,32,97,32,
+99,111,110,116,97,105,110,101,114,59,32,114,101,99,97,115,
+116,32,116,104,101,32,99,111,110,116,97,105,110,101,114,32,
+105,110,115,116,101,97,100,0,1616039,1586469,12,8,1616735,14,1310721,2,
+7,26,2,13,28,1,6,1,10,28,34,63,38,3,26,1616285,
+16,1310721,2,5,26,2,1616273,14,105,115,32,98,111,114,114,111,
+119,101,100,32,97,110,100,32,99,97,110,39,116,32,98,101,
+32,114,101,99,97,115,116,0,1616209,1586469,12,8,1616735,14,1310721,2,
+7,26,2,1,28,1,6,1,10,28,34,63,38,3,26,1616393,
+16,1310721,2,5,26,2,1616381,14,105,115,110,39,116,32,97,110,
+32,111,119,110,101,100,32,111,98,106,101,99,116,0,1616337,1586469,
+12,8,1616735,14,1310721,2,7,26,2,9,28,1,6,1,10,28,
+34,63,38,3,26,1616515,16,1310721,2,5,26,2,1616503,14,117,115,
+101,100,32,97,102,116,101,114,32,105,116,32,119,97,115,32,
+103,105,118,101,110,32,97,119,97,121,0,1616445,1586469,12,8,1616735,
+14,1310721,2,3,26,2,3,28,1,6,1,10,28,34,63,38,
+3,26,1616615,16,1310721,2,7,26,2,3,28,1,6,1,10,28,
+34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,10,
+28,1616617,14,1,1616699,16,1310721,2,5,26,2,1616687,14,99,97,110,
+39,116,32,98,101,32,114,101,99,97,115,116,32,98,97,99,
+107,32,116,111,32,109,0,1616635,1586469,12,8,1616735,14,1469953,1310721,2,
+5,26,2,26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,
+2,2,1616747,14,1,1310721,2,9,26,1310721,4,18,1310721,2,9,28,
+1310721,4,1310721,2,1835009,40,1616795,16,1966081,1310721,4,1579069,12,1310721,2,3,
+26,4,1310721,2,4,1584853,2,1,6,1,10,28,34,63,38,3,
+26,1616845,16,1,1618279,14,1310721,2,2,3,28,1,6,1,10,28,
+34,63,38,3,26,1617089,16,1310721,2,3,26,2,5,28,1,6,
+1,10,28,34,63,38,1,10,28,1617083,16,1617075,14,97,32,110,
+101,119,32,111,98,106,101,99,116,32,99,97,110,32,111,110,
+108,121,32,103,111,32,115,116,114,97,105,103,104,116,32,116,
+111,32,97,32,100,32,112,97,114,97,109,101,116,101,114,59,
+32,98,105,110,100,32,105,116,32,116,111,32,97,32,110,97,
+109,101,32,102,105,114,115,116,0,1616923,1586351,12,8,1,1618279,14,
+1310721,2,2,5,40,1617109,16,3,1617165,14,1310721,2,2,5,28,1604491,
+12,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1617175,16,1,1618279,14,1310721,2,5,26,1310721,
+2,2,5,28,10,3,6,10,4,8,1310721,2,7,26,1469953,1310721,
+2,5,26,2,26,2,10,3,6,10,4,8,1469953,1310721,2,5,
+26,2,1604353,12,26,2,9,28,1,6,1,10,28,34,63,38,
+3,26,1617375,16,1310721,2,5,26,2,1617361,14,117,115,101,100,32,
+97,102,116,101,114,32,105,116,32,119,97,115,32,103,105,118,
+101,110,32,97,119,97,121,0,1617303,1586469,12,8,1,1618279,14,1310721,
+2,3,26,2,3,10,40,3,36,1617603,16,1310721,2,7,26,2,
+7,28,1,6,1,10,28,34,63,38,3,26,1617581,16,1310721,2,
+5,26,2,1617567,14,105,115,32,100,59,32,112,97,115,115,32,
+105,116,32,116,111,32,97,32,100,32,112,97,114,97,109,101,
+116,101,114,32,40,108,101,110,100,105,110,103,32,105,116,32,
+119,111,117,108,100,32,108,111,115,101,32,105,116,41,0,1617451,
+1586469,12,8,1,1618279,14,1310721,2,5,26,2,1604589,12,8,1,1618279,
+14,1310721,2,7,26,2,7,28,1,6,1,10,28,34,63,38,
+3,26,1617703,16,1469953,1310721,2,5,26,2,26,9,10,3,6,10,
+4,8,1472001,1310721,2,5,26,2,26,3,10,3,6,10,4,8,
+1,1618279,14,1310721,2,7,26,2,3,28,1,6,1,10,28,34,
+63,38,3,26,1617831,16,1310721,2,5,26,2,1617819,14,105,115,32,
+109,59,32,119,114,105,116,101,32,100,42,120,32,116,111,32,
+103,105,118,101,32,105,116,32,97,119,97,121,0,1617755,1586469,12,
+8,1618271,14,1310721,2,7,26,2,5,28,1,6,1,10,28,34,
+63,38,3,26,1618007,16,1310721,2,5,26,2,1617995,14,105,115,32,
+117,59,32,119,114,105,116,101,32,100,42,120,32,116,111,32,
+103,105,118,101,32,105,116,32,97,119,97,121,32,105,110,115,
+116,101,97,100,32,111,102,32,114,101,116,117,114,110,105,110,
+103,32,105,116,0,1617883,1586469,12,8,1618271,14,1310721,2,7,26,2,
+11,28,1,6,1,10,28,34,63,38,3,26,1618177,16,1310721,2,
+5,26,2,1618165,14,98,101,108,111,110,103,115,32,116,111,32,
+97,32,99,111,110,116,97,105,110,101,114,32,97,110,100,32,
+99,97,110,39,116,32,98,101,32,103,105,118,101,110,32,97,
+119,97,121,32,97,108,111,110,101,0,1618059,1586469,12,8,1618271,14,
+1310721,2,5,26,2,1618263,14,105,115,32,98,111,114,114,111,119,
+101,100,32,97,110,100,32,99,97,110,39,116,32,98,101,32,
+103,105,118,101,110,32,97,119,97,121,0,1618191,1586469,12,8,1,
+1618279,14,1,1310721,2,9,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1618327,16,1966081,1310721,4,1579069,12,1310721,2,4,1467905,1310721,
+2,2,26,2,1590069,12,8,3,1589235,12,8,1584961,2,1589915,12,8,
+1,1618377,14,1,1310721,2,3,26,1310721,4,18,1310721,2,15,28,1310721,
+4,1310721,2,1835009,40,1618425,16,1966081,1310721,4,1579069,12,1310721,2,5,26,
+4,1310721,2,3,26,4,1310721,2,4,1584853,2,1,6,1,10,28,
+34,63,38,3,26,1618485,16,1,1621915,14,1310721,2,9,26,3,1,
+10,28,10,3,6,10,4,8,1310721,2,5,26,2,5,40,3,
+36,1618579,16,1310721,2,5,26,2,5,28,1604491,12,1,6,1,10,
+28,34,63,38,1,10,28,1618581,14,1,1618619,16,1310721,2,9,26,
+1310721,2,5,26,2,5,28,10,3,6,10,4,8,1310721,2,9,
+26,2,1,40,3,36,1618711,16,1469953,1310721,2,9,26,2,1604353,12,
+26,2,9,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1618713,14,1,1618803,16,1310721,2,
+9,26,2,1618789,14,117,115,101,100,32,97,102,116,101,114,32,
+105,116,32,119,97,115,32,103,105,118,101,110,32,97,119,97,
+121,0,1618731,1586469,12,8,1,1621915,14,1310721,2,2,3,28,1,6,
+1,10,28,34,63,38,3,26,1620259,16,1310721,2,7,26,1469953,1310721,
+2,3,26,2,26,2,10,3,6,10,4,8,1310721,2,9,26,
+2,1,40,1618953,16,1310721,2,5,26,2,3,28,1,6,1,10,
+28,34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,
+10,28,1618955,14,1,1619159,16,1310721,2,7,26,2,1607831,12,1,6,
+1,10,28,34,63,38,3,26,1619125,16,1310721,2,3,26,2,1619113,
+14,115,116,105,108,108,32,111,119,110,115,32,97,110,32,111,
+98,106,101,99,116,59,32,111,118,101,114,119,114,105,116,105,
+110,103,32,105,116,32,119,111,117,108,100,32,108,101,97,107,
+32,105,116,0,1619011,1586469,12,8,1619153,14,1469953,1310721,2,3,26,2,
+26,1,10,3,6,10,4,8,1,1621915,14,1310721,2,7,26,2,
+1607831,12,1,6,1,10,28,34,63,38,3,26,1619327,16,1310721,2,
+3,26,2,1619313,14,115,116,105,108,108,32,111,119,110,115,32,
+97,110,32,111,98,106,101,99,116,59,32,111,118,101,114,119,
+114,105,116,105,110,103,32,105,116,32,119,111,117,108,100,32,
+108,101,97,107,32,105,116,0,1619211,1586469,12,8,1,1621915,14,1310721,
+2,5,26,2,3,28,1,6,1,10,28,34,63,38,3,26,
+1619517,16,1469953,1310721,2,3,26,2,26,3,10,3,6,10,4,8,
+1472001,1310721,2,3,26,2,26,1,10,3,6,10,4,8,1474049,1310721,
+2,3,26,2,26,3,10,3,6,10,4,8,1558017,1310721,2,3,
+26,2,26,2,1619511,16,1469953,1310721,2,3,26,2,26,1558017,1310721,2,
+3,26,2,26,2,10,3,6,10,4,8,1,1621915,14,1310721,2,
+13,26,1469953,1310721,2,9,26,2,26,2,10,3,6,10,4,8,
+1310721,2,13,26,2,5,28,1,6,1,10,28,34,63,38,3,
+26,1619675,16,1468929,1310721,2,3,26,2,26,2,1468929,1310721,2,9,26,
+2,26,2,3,28,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1619677,14,1,1619889,16,
+1469953,1310721,2,3,26,2,26,3,10,3,6,10,4,8,1472001,1310721,
+2,3,26,2,26,1,10,3,6,10,4,8,1474049,1310721,2,3,
+26,2,26,3,10,3,6,10,4,8,1469953,1310721,2,9,26,2,
+26,9,10,3,6,10,4,8,1472001,1310721,2,9,26,2,26,3,
+10,3,6,10,4,8,1558017,1310721,2,3,26,2,26,2,1619883,16,
+1469953,1310721,2,3,26,2,26,1558017,1310721,2,3,26,2,26,2,10,
+3,6,10,4,8,1,1621915,14,1310721,2,13,26,2,5,28,1,
+6,1,10,28,34,63,38,3,26,1620109,16,1310721,2,9,26,2,
+1620097,14,105,115,32,117,59,32,105,116,32,99,97,110,32,111,
+110,108,121,32,98,101,32,104,97,110,100,101,100,32,116,111,
+32,97,32,118,97,114,105,97,98,108,101,32,111,102,32,116,
+104,101,32,101,110,99,108,111,115,105,110,103,32,98,108,111,
+99,107,44,32,111,114,32,114,101,116,117,114,110,101,100,0,
+1619941,1586469,12,8,1620253,14,1310721,2,9,26,2,1620245,14,105,115,32,
+97,110,32,111,119,110,101,100,32,111,98,106,101,99,116,32,
+97,110,100,32,99,97,110,39,116,32,98,101,32,99,111,112,
+105,101,100,32,105,110,116,111,32,97,110,111,116,104,101,114,
+32,118,97,114,105,97,98,108,101,0,1620123,1586469,12,8,1,1621915,
+14,1310721,2,2,7,28,1,6,1,10,28,34,63,38,3,26,
+1621583,16,1310721,2,11,26,1310721,2,3,26,2,1604353,12,10,3,6,
+10,4,8,1310721,2,7,26,1469953,1310721,2,11,26,2,26,2,10,
+3,6,10,4,8,1310721,2,3,26,2,1604589,12,8,1310721,2,5,
+26,2,3,28,1,6,1,10,28,34,63,38,3,26,1620439,16,
+1310721,2,3,26,2,1618293,12,8,1,1621915,14,1310721,2,9,26,2,
+1,40,1620463,16,1,1621915,14,1310721,2,13,26,1469953,1310721,2,9,26,
+2,26,2,10,3,6,10,4,8,1310721,2,13,26,2,11,28,
+1,6,1,10,28,34,63,38,3,26,1620625,16,1310721,2,9,26,
+2,1620613,14,97,108,114,101,97,100,121,32,98,101,108,111,110,
+103,115,32,116,111,32,97,32,99,111,110,116,97,105,110,101,
+114,0,1620551,1586469,12,8,1621577,14,1310721,2,13,26,2,13,28,1,
+6,1,10,28,34,63,38,3,26,1620753,16,1310721,2,9,26,2,
+1620741,14,105,115,32,98,111,114,114,111,119,101,100,32,97,110,
+100,32,99,97,110,39,116,32,98,101,32,115,116,111,114,101,
+100,0,1620677,1586469,12,8,1621577,14,1310721,2,7,26,2,13,28,1,
+6,1,10,28,34,63,38,3,26,1621079,16,1310721,2,13,26,2,
+5,28,1,6,1,10,28,34,63,38,3,26,1621003,16,1310721,2,
+9,26,2,1620991,14,105,115,32,117,59,32,105,116,32,104,97,
+115,32,116,111,32,108,101,97,118,101,32,116,104,114,111,117,
+103,104,32,116,104,101,32,98,108,111,99,107,32,97,98,111,
+118,101,44,32,110,111,116,32,105,110,116,111,32,97,32,98,
+111,114,114,111,119,101,100,32,111,98,106,101,99,116,0,1620843,
+1586469,12,8,1621075,14,1469953,1310721,2,9,26,2,26,9,10,3,6,
+10,4,8,1472001,1310721,2,9,26,2,26,3,10,3,6,10,4,
+8,1310721,2,3,26,2,1618293,12,8,1621577,14,1310721,2,13,26,2,
+1310721,2,7,26,2,28,1,6,1,10,28,34,63,38,1,10,
+28,1621285,16,1310721,2,9,26,2,1621273,14,105,116,115,32,116,97,
+103,32,100,111,101,115,110,39,116,32,109,97,116,99,104,32,
+105,116,115,32,99,111,110,116,97,105,110,101,114,39,115,32,
+40,98,111,116,104,32,104,97,118,101,32,116,111,32,98,101,
+32,109,44,32,117,32,111,114,32,100,41,0,1621141,1586469,12,8,
+1621577,14,1468929,1310721,2,9,26,2,26,2,1468929,1310721,2,11,26,2,
+26,2,40,1621469,16,1310721,2,9,26,2,1621457,14,108,105,118,101,
+115,32,105,110,32,97,110,32,111,117,116,101,114,32,98,108,
+111,99,107,32,116,104,97,110,32,116,104,101,32,99,111,110,
+116,97,105,110,101,114,32,105,116,39,115,32,115,116,111,114,
+101,100,32,105,110,116,111,0,1621337,1586469,12,8,1621577,14,1469953,1310721,
+2,9,26,2,26,11,10,3,6,10,4,8,1470977,1310721,2,9,
+26,2,26,1310721,2,3,26,2,10,3,6,10,4,8,1472001,1310721,
+2,9,26,2,26,3,10,3,6,10,4,8,1310721,2,3,26,
+2,1618293,12,8,1,1621915,14,1310721,2,9,26,2,1,40,3,36,
+1621907,16,1469953,1310721,2,9,26,2,26,2,7,28,1,6,1,10,
+28,34,63,38,3,26,1621709,16,1469953,1310721,2,9,26,2,26,9,
+10,3,6,10,4,8,1472001,1310721,2,9,26,2,26,3,10,3,
+6,10,4,8,1621907,14,1310721,2,9,26,2,1621899,14,109,117,115,
+116,32,98,101,32,100,32,116,111,32,98,101,32,115,116,111,
+114,101,100,32,105,110,32,97,32,103,108,111,98,97,108,32,
+111,114,32,105,110,32,117,110,116,114,97,99,107,101,100,32,
+109,101,109,111,114,121,32,40,116,104,101,32,99,111,108,108,
+101,99,116,111,114,32,116,97,107,101,115,32,105,116,32,111,
+118,101,114,41,0,1621723,1586469,12,8,1,1621915,14,1,1310721,2,15,
+26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1621963,16,
+1966081,1310721,4,1579069,12,1310721,2,4,1584853,2,1,6,1,10,28,34,
+63,38,3,26,1622003,16,1,1622897,14,1310721,2,3,26,3,1,10,
+28,10,3,6,10,4,8,1310721,2,2,5,40,3,36,1622089,16,
+1310721,2,2,5,28,1604491,12,1,6,1,10,28,34,63,38,1,
+10,28,1622091,14,1,1622125,16,1310721,2,3,26,1310721,2,2,5,28,
+10,3,6,10,4,8,1310721,2,3,26,2,1,40,3,36,1622217,
+16,1469953,1310721,2,3,26,2,1604353,12,26,2,9,28,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1622219,14,1,1622309,16,1310721,2,3,26,2,1622295,14,117,115,
+101,100,32,97,102,116,101,114,32,105,116,32,119,97,115,32,
+103,105,118,101,110,32,97,119,97,121,0,1622237,1586469,12,8,1,
+1622897,14,1584855,2,1622565,16,1310721,2,3,26,2,1,40,3,36,1622559,
+16,1469953,1310721,2,3,26,2,26,2,5,28,1,6,1,10,28,
+34,63,38,3,26,1622443,16,1469953,1310721,2,3,26,2,26,9,10,
+3,6,10,4,8,1472001,1310721,2,3,26,2,26,3,10,3,6,
+10,4,8,1622559,14,1310721,2,3,26,2,1622551,14,104,97,115,32,
+116,111,32,98,101,32,117,32,116,111,32,98,101,32,114,101,
+116,117,114,110,101,100,59,32,119,114,105,116,101,32,39,114,
+101,116,117,114,110,32,117,42,120,39,0,1622457,1586469,12,8,1,
+1622897,14,1310721,2,2,3,28,1,6,1,10,28,34,63,38,3,
+26,1622723,16,1622711,14,114,101,116,117,114,110,115,32,97,32,110,
+101,119,32,111,98,106,101,99,116,59,32,100,101,99,108,97,
+114,101,32,116,104,101,32,102,117,110,99,116,105,111,110,32,
+119,105,116,104,32,45,62,32,46,117,0,1622603,1586351,12,8,1622889,
+14,1310721,2,3,26,2,1,40,3,36,1622889,16,1310721,2,3,26,
+2,1622881,14,105,115,32,111,119,110,101,100,32,97,110,100,32,
+99,97,110,39,116,32,98,101,32,114,101,116,117,114,110,101,
+100,32,102,114,111,109,32,97,32,102,117,110,99,116,105,111,
+110,32,119,105,116,104,111,117,116,32,45,62,32,46,117,0,
+1622759,1586469,12,8,1,1622897,14,1,1310721,2,5,26,1310721,4,18,1310721,
+2,5,28,1310721,4,1310721,2,1835009,40,1622945,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1584853,2,1,6,1,10,28,34,63,38,3,26,1622985,
+16,1,1623613,14,1310721,2,2,3,28,1,6,1,10,28,34,63,
+38,3,26,1623025,16,3,1623613,14,1310721,2,2,5,40,1623045,16,3,
+1623101,14,1310721,2,2,5,28,1604491,12,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1623111,16,
+1,1623613,14,1310721,2,3,26,1310721,2,2,5,28,10,3,6,10,
+4,8,1469953,1310721,2,3,26,2,26,2,5,28,1,6,1,10,
+28,34,63,38,3,26,1623253,16,1468929,1310721,2,3,26,2,26,2,
+1584849,2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1623255,14,1,1623321,16,1469953,1310721,2,
+3,26,2,26,9,10,3,6,10,4,8,1472001,1310721,2,3,26,
+2,26,3,10,3,6,10,4,8,3,1623613,14,1469953,1310721,2,3,
+26,2,26,2,5,28,1,6,1,10,28,34,63,38,3,26,
+1623485,16,1310721,2,3,26,2,1623473,14,111,110,108,121,32,97,32,
+117,32,111,98,106,101,99,116,32,111,102,32,116,104,105,115,
+32,98,108,111,99,107,32,99,97,110,32,98,101,32,105,116,
+115,32,118,97,108,117,101,0,1623379,1586469,12,8,1623605,14,1310721,2,
+3,26,2,1623597,14,104,97,115,32,116,111,32,98,101,32,117,
+32,116,111,32,98,101,32,104,97,110,100,101,100,32,117,112,
+32,97,115,32,116,104,101,32,98,108,111,99,107,39,115,32,
+118,97,108,117,101,0,1623499,1586469,12,8,1,1623613,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1623661,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,3,28,1,6,
+1,10,28,34,63,38,3,26,1623817,16,1623805,14,97,32,110,101,
+119,32,111,98,106,101,99,116,32,40,111,114,32,97,32,117,
+32,114,101,115,117,108,116,41,32,99,97,110,39,116,32,98,
+101,32,116,104,114,111,119,110,32,97,119,97,121,0,1623705,1586351,
+12,8,1623851,14,1310721,2,2,5,40,3,36,1623851,16,1310721,2,2,
+5,28,1604589,12,8,1,1623859,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,5,28,1310721,4,1310721,2,1835009,40,1623907,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1584971,2,1310721,2,3,26,4,1584971,2,1310721,2,2,
+26,1310721,40,3,36,1624007,16,1623999,14,116,104,101,32,116,121,112,
+101,32,97,114,101,97,32,105,115,32,102,117,108,108,0,1623955,
+1585585,12,8,1584971,1584971,2,1310721,2,2,26,10,3,6,10,4,8,
+1310721,2,3,26,2,1,1310721,2,2,1574549,12,8,1310721,2,3,26,
+2,1624073,14,1,1310721,2,5,26,1310721,4,18,1310721,2,11,28,1310721,
+4,1310721,2,1835009,40,1624121,16,1966081,1310721,4,1579069,12,1310721,2,7,26,
+4,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,15,1310721,
+2,7,26,2,26,1623873,12,1310721,2,9,26,4,1310721,2,9,26,
+2,1,26,1310721,2,2,10,3,6,10,4,8,1310721,2,9,26,
+2,3,26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,2,
+9,26,2,5,26,1310721,2,5,26,2,10,3,6,10,4,8,
+1584973,2,2049,40,3,36,1624347,16,1624339,14,116,111,111,32,109,97,
+110,121,32,116,121,112,101,115,0,1624309,1585585,12,8,1277953,1584973,2,
+26,1310721,2,9,26,2,10,3,6,10,4,8,1584973,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1310721,2,9,26,2,1624421,
+14,1,1310721,2,11,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,
+2,1835009,40,1624469,16,1966081,1310721,4,1579069,12,1310721,2,4,1,1310721,2,
+3,26,4,1310721,2,3,26,2,1584973,2,40,1624715,16,1310721,2,5,
+26,1277953,1310721,2,3,26,2,26,2,10,3,6,10,4,8,1310721,
+2,5,26,2,1,26,2,11,28,1,6,1,10,28,34,63,
+38,3,26,1624657,16,1310721,2,5,26,2,9,26,2,1310721,2,2,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1624659,14,1,1624677,16,1310721,2,5,26,2,
+1624795,14,1310721,2,3,26,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1624487,14,1310721,2,5,26,11,3,1,1,1624087,12,10,
+3,6,10,4,8,1310721,2,5,26,2,9,26,1310721,2,2,10,
+3,6,10,4,8,1310721,2,5,26,2,1624795,14,1,1310721,2,7,
+26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1624843,16,
+1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1,1310721,2,
+5,26,4,1310721,2,5,26,2,1584973,2,40,1625179,16,1310721,2,7,
+26,1277953,1310721,2,5,26,2,26,2,10,3,6,10,4,8,1310721,
+2,7,26,2,1,26,2,13,28,1,6,1,10,28,34,63,
+38,3,26,1625041,16,1310721,2,7,26,2,9,26,2,1310721,2,2,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1625043,14,1,1625121,16,1310721,2,7,26,2,
+7,26,2,1310721,2,3,26,2,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1625123,14,
+1,1625141,16,1310721,2,7,26,2,1625315,14,1310721,2,5,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1624871,14,1310721,2,7,
+26,13,1310721,2,3,26,2,1310721,2,2,1628577,12,30,1,1,1624087,
+12,10,3,6,10,4,8,1310721,2,7,26,2,9,26,1310721,2,
+2,10,3,6,10,4,8,1310721,2,7,26,2,7,26,1310721,2,
+3,26,2,10,3,6,10,4,8,1310721,2,7,26,2,1625315,14,
+1,1310721,2,9,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,2,
+1835009,40,1625363,16,1966081,1310721,4,1579069,12,1310721,2,7,26,4,1310721,2,
+5,26,4,1310721,2,3,26,4,1310721,2,4,1,1310721,2,9,26,
+4,1310721,2,9,26,2,1584973,2,40,1626037,16,1310721,2,13,26,1277953,
+1310721,2,9,26,2,26,2,10,3,6,10,4,8,1310721,2,13,
+26,2,1,26,2,15,28,1,6,1,10,28,34,63,38,3,
+26,1625581,16,1310721,2,13,26,2,9,26,2,1310721,2,2,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1625583,14,1,1625661,16,1310721,2,13,26,2,7,26,
+2,1310721,2,3,26,2,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1625663,14,1,1625741,
+16,1310721,2,13,26,2,11,26,2,1310721,2,7,26,2,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1625743,14,1,1625999,16,1310721,2,11,26,1,10,3,
+6,10,4,8,1310721,2,11,26,2,1310721,2,3,26,2,40,1625895,
+16,1310721,2,13,26,2,15,1310721,2,11,26,2,26,26,2,1310721,
+2,5,26,2,1310721,2,11,26,2,26,2,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1625897,14,1,1625939,16,1310721,2,11,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1625769,14,1310721,2,11,26,2,1310721,2,
+3,26,2,28,1,6,1,10,28,34,63,38,3,26,1625999,16,
+1310721,2,13,26,2,1626237,14,1310721,2,9,26,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1625411,14,1310721,2,13,26,15,3,
+1,1310721,2,3,26,2,1624087,12,10,3,6,10,4,8,1310721,2,
+13,26,2,9,26,1310721,2,2,10,3,6,10,4,8,1310721,2,
+13,26,2,7,26,1310721,2,3,26,2,10,3,6,10,4,8,
+1310721,2,13,26,2,11,26,1310721,2,7,26,2,10,3,6,10,
+4,8,1310721,2,13,26,2,15,26,1310721,2,5,26,2,1310721,2,
+3,26,2,1574337,12,8,1310721,2,13,26,2,1626237,14,1,1310721,2,
+15,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1626285,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1,1310721,
+2,5,26,4,1310721,2,5,26,2,1584973,2,40,1626541,16,1310721,2,
+7,26,1277953,1310721,2,5,26,2,26,2,10,3,6,10,4,8,
+1310721,2,7,26,2,1,26,2,19,28,1,6,1,10,28,34,
+63,38,3,26,1626483,16,1310721,2,7,26,2,7,26,2,1310721,2,
+2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1626485,14,1,1626503,16,1310721,2,7,26,
+2,1626629,14,1310721,2,5,26,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1626313,14,1310721,2,7,26,19,3,1310721,2,3,26,
+2,1,1624087,12,10,3,6,10,4,8,1310721,2,7,26,2,7,
+26,1310721,2,2,10,3,6,10,4,8,1310721,2,7,26,2,1626629,
+14,1,1310721,2,9,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,
+2,1835009,40,1626677,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,1310721,
+2,3,26,4,1310721,2,4,1,1310721,2,7,26,4,1310721,2,7,
+26,2,1584973,2,40,1627217,16,1310721,2,11,26,1277953,1310721,2,7,26,
+2,26,2,10,3,6,10,4,8,1310721,2,11,26,2,1,26,
+2,17,28,1,6,1,10,28,34,63,38,3,26,1626885,16,1310721,
+2,11,26,2,11,26,2,1310721,2,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1626887,14,1,1627179,16,1310721,2,13,26,1310721,2,11,26,2,13,26,
+2,10,3,6,10,4,8,1310721,2,9,26,1,10,3,6,10,
+4,8,1310721,2,9,26,2,1310721,2,5,26,2,40,1627075,16,1310721,
+2,13,26,2,3,1310721,2,9,26,2,26,26,2,1310721,2,3,
+26,2,1310721,2,9,26,2,26,2,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1627077,
+14,1,1627119,16,1310721,2,9,26,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1626949,14,1310721,2,9,26,2,1310721,2,5,26,
+2,28,1,6,1,10,28,34,63,38,3,26,1627179,16,1310721,2,
+11,26,2,1627491,14,1310721,2,7,26,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1626715,14,1310721,2,13,26,1310721,2,5,26,
+2,3,26,1623873,12,10,3,6,10,4,8,1310721,2,13,26,2,
+1,26,1310721,2,5,26,2,10,3,6,10,4,8,1310721,2,13,
+26,2,3,26,1310721,2,3,26,2,1310721,2,5,26,2,1574337,12,
+8,1310721,2,11,26,17,1,1310721,2,2,5,26,2,1,1624087,12,
+10,3,6,10,4,8,1310721,2,11,26,2,7,26,3,1,10,
+28,10,3,6,10,4,8,1310721,2,11,26,2,11,26,1310721,2,
+2,10,3,6,10,4,8,1310721,2,11,26,2,13,26,1310721,2,
+13,26,2,10,3,6,10,4,8,1310721,2,11,26,2,1627491,14,
+1,1310721,2,15,26,1310721,4,18,1310721,2,33,28,1310721,4,1310721,2,
+1835009,40,1627539,16,1966081,1310721,4,1579069,12,1310721,2,4,1,1310721,2,13,
+26,4,1310721,2,2,1,26,2,17,28,1,6,1,10,28,34,
+63,38,1,10,28,1627605,16,3,1627647,14,1310721,2,2,7,26,2,
+1,40,3,36,1,6,1,10,28,34,63,38,1,10,28,1627661,
+16,1310721,2,2,1628563,14,1310721,2,2,7,26,2,5,1,10,28,
+28,1,6,1,10,28,34,63,38,3,26,1627831,16,1627789,14,97,
+32,115,116,114,117,99,116,32,99,97,110,39,116,32,99,111,
+110,116,97,105,110,32,105,116,115,101,108,102,32,98,121,32,
+118,97,108,117,101,0,1627711,1585679,12,8,1310721,2,2,7,26,1,
+10,3,6,10,4,8,1310721,2,2,1628563,14,1310721,2,2,7,26,
+5,1,10,28,10,3,6,10,4,8,1310721,2,3,26,1310721,2,
+2,11,26,2,10,3,6,10,4,8,1310721,2,7,26,1310721,2,
+3,26,2,11,26,2,10,3,6,10,4,8,1310721,2,5,26,
+1310721,2,3,26,2,9,26,2,10,3,6,10,4,8,1310721,2,
+17,26,1,17,1574549,12,8,1310721,2,17,26,1310721,2,2,13,26,
+2,3,26,1310721,2,2,13,26,2,1,26,2,1574337,12,8,1310721,
+2,11,26,1310721,2,7,26,2,7,30,3,26,1623873,12,10,3,
+6,10,4,8,1310721,2,9,26,1,10,3,6,10,4,8,1310721,
+2,9,26,2,1310721,2,7,26,2,40,1628455,16,1310721,2,15,26,
+1310721,2,5,26,2,1310721,2,9,26,2,1310721,2,9,26,2,26,
+3,26,26,2,1310721,2,17,26,1628749,12,10,3,6,10,4,8,
+1310721,2,11,26,2,1310721,2,9,26,2,7,30,26,1310721,2,5,
+26,2,1310721,2,9,26,2,1310721,2,9,26,2,26,26,2,10,
+3,6,10,4,8,1310721,2,11,26,2,1310721,2,9,26,2,7,
+30,3,26,26,1310721,2,15,26,2,10,3,6,10,4,8,1310721,
+2,11,26,2,1310721,2,9,26,2,7,30,5,26,26,1310721,2,
+13,26,2,10,3,6,10,4,8,1310721,2,13,26,1310721,2,13,
+26,2,1310721,2,15,26,2,1628577,12,26,10,3,6,10,4,8,
+1310721,2,9,26,1,6,2,1,6,3,26,5,6,4,10,8,
+8,1628095,14,1310721,2,2,9,26,1310721,2,11,26,2,10,3,6,
+10,4,8,1310721,2,2,3,26,1310721,2,13,26,2,10,3,6,
+10,4,8,1310721,2,2,7,26,1310721,2,7,26,2,10,3,6,
+10,4,8,1310721,2,2,1628563,14,1,1310721,2,33,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1628611,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1310721,2,2,1,26,2,17,28,1,6,1,10,
+28,34,63,38,3,26,1628699,16,1310721,2,2,7,26,2,1,40,
+1,6,1,10,28,34,63,38,1,10,28,1628701,14,1,1628717,16,
+1310721,2,2,1627505,12,8,1310721,2,2,3,26,2,1628735,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,61,28,1310721,4,1310721,2,1835009,40,
+1628783,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,
+2,2,1,26,2,1310721,2,5,26,4,1310721,2,5,26,2,19,
+28,1,6,1,10,28,34,63,38,3,26,1628927,16,1310721,2,3,
+26,2,1310721,2,2,7,26,2,26,2,1628919,16,1310721,2,3,26,
+2,1310721,2,2,7,26,2,26,2,1629733,14,1584975,2,1629733,14,1310721,
+2,5,26,2,11,28,1,6,1,10,28,34,63,38,3,26,
+1628999,16,1310721,2,2,9,26,2,1310721,2,3,26,2,1628749,12,1624435,
+12,1629733,14,1310721,2,5,26,2,13,28,1,6,1,10,28,34,
+63,38,3,26,1629083,16,1310721,2,2,9,26,2,1310721,2,3,26,
+2,1628749,12,1310721,2,2,7,26,2,1624809,12,1629733,14,1310721,2,5,
+26,2,15,28,1,6,1,10,28,34,63,38,3,26,1629373,16,
+1310721,2,9,26,1310721,2,2,7,26,2,10,3,6,10,4,8,
+1310721,2,7,26,1,10,3,6,10,4,8,1310721,2,7,26,2,
+1310721,2,9,26,2,40,1629309,16,1310721,2,11,26,1310721,2,7,26,
+2,26,1310721,2,2,15,1310721,2,7,26,2,26,26,2,1310721,2,
+3,26,2,1628749,12,10,3,6,10,4,8,1310721,2,7,26,1,
+6,2,1,6,3,26,5,6,4,10,8,8,1629175,14,1310721,2,
+2,9,26,2,1310721,2,3,26,2,1628749,12,1310721,2,9,26,2,
+1310721,2,11,26,1310721,2,2,11,26,2,1625329,12,1629733,14,1310721,2,
+5,26,2,17,28,1,6,1,10,28,34,63,38,3,26,1629449,
+16,1310721,2,2,11,26,2,1,6,1,10,28,34,63,38,1,
+10,28,1629451,14,1,1629721,16,1310721,2,59,26,1310721,2,2,13,26,
+2,10,3,6,10,4,8,1310721,2,9,26,1310721,2,59,26,2,
+1,26,2,10,3,6,10,4,8,1310721,2,7,26,1,10,3,
+6,10,4,8,1310721,2,7,26,2,1310721,2,9,26,2,40,1629683,
+16,1310721,2,11,26,1310721,2,7,26,2,26,1310721,2,59,26,2,
+3,1310721,2,7,26,2,26,26,2,1310721,2,3,26,2,1628749,12,
+10,3,6,10,4,8,1310721,2,7,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1629545,14,1310721,2,2,11,26,2,1310721,
+2,11,26,1310721,2,9,26,2,1626643,12,1629733,14,1310721,2,2,1629733,
+14,1,1310721,2,61,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,
+2,1835009,40,1629781,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,
+1,26,2,3,28,1,6,1,10,28,34,63,38,3,26,1629833,
+16,3,1629891,14,1310721,2,2,1,26,2,5,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1629901,16,3,1629959,14,1310721,2,2,1,26,2,7,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1629965,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,
+28,1310721,4,1310721,2,1835009,40,1630013,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,1,26,2,13,28,1,6,1,10,28,34,63,
+38,3,26,1630065,16,3,1630123,14,1310721,2,2,1,26,2,17,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1630129,14,1,1310721,2,3,26,1310721,4,18,1310721,
+2,3,28,1310721,4,1310721,2,1835009,40,1630177,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,1,26,2,11,28,1,6,1,10,28,
+34,63,38,3,26,1630229,16,3,1630287,14,1310721,2,2,1,26,2,
+13,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1630293,14,1,1310721,2,3,26,1310721,4,
+18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1630341,16,1966081,1310721,4,
+1579069,12,1310721,2,4,1310721,2,2,1,26,2,13,28,1,6,1,
+10,28,34,63,38,3,26,1630407,16,1310721,2,2,9,26,2,1624435,
+12,1630419,14,1310721,2,2,1630419,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1630467,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1310721,2,2,1,26,2,11,28,1,6,1,10,
+28,34,63,38,3,26,1630519,16,3,1630577,14,1310721,2,2,1,26,
+2,13,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1630597,16,1310721,2,2,9,26,2,
+1630607,14,1584975,2,1630607,14,1,1310721,2,3,26,1310721,4,18,1310721,2,
+5,28,1310721,4,1310721,2,1835009,40,1630655,16,1966081,1310721,4,1579069,12,1310721,
+2,3,26,4,1310721,2,4,1310721,2,2,1310721,2,3,26,2,28,
+1,6,1,10,28,34,63,38,3,26,1630719,16,3,1630773,14,1310721,
+2,2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1630783,16,3,1630841,14,1310721,
+2,3,26,2,1584975,2,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1630851,16,3,1631577,
+14,1310721,2,2,1629747,12,1630905,16,1310721,2,3,26,2,1629747,12,1,
+6,1,10,28,34,63,38,1,10,28,1630907,14,1,1630917,16,3,
+1631577,14,1310721,2,3,26,1310721,2,3,26,2,1630307,12,10,3,6,
+10,4,8,1310721,2,2,1,26,2,11,28,1,6,1,10,28,
+34,63,38,3,26,1631057,16,1310721,2,3,26,2,1,26,2,11,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1631059,14,1,1631383,16,1310721,2,2,9,26,
+2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,1631111,16,
+3,1631175,14,1310721,2,3,26,2,9,26,2,1584975,2,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1631185,16,3,1631245,14,1310721,2,2,9,26,2,1584983,2,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1631255,16,3,1631319,14,1310721,2,3,26,2,
+9,26,2,1584983,2,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1631329,16,3,1631577,14,
+1310721,2,2,9,26,2,1310721,2,3,26,2,9,26,2,28,1,
+6,1,10,28,34,63,38,3,26,1631577,14,1310721,2,2,1,26,
+2,11,28,1,6,1,10,28,34,63,38,3,26,1631429,16,3,
+1631487,14,1310721,2,2,1,26,2,15,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1631521,
+16,1584989,2,1,6,1,10,28,34,63,38,1,10,28,1631523,14,
+1,1631533,16,3,1631577,14,1310721,2,2,1310721,2,3,26,2,28,1,
+6,1,10,28,34,63,38,3,26,1631577,14,1,1310721,2,5,26,
+1310721,4,18,1310721,2,15,28,1310721,4,1310721,2,1835009,40,1631625,16,1966081,
+1310721,4,1579069,12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,
+4,1310721,2,2,1,26,2,19,28,1,6,1,10,28,34,63,
+38,3,26,1631863,16,1310721,2,7,26,1310721,2,2,7,26,2,10,
+3,6,10,4,8,1310721,2,5,26,2,1310721,2,7,26,2,26,
+2,1,6,1,10,28,34,63,38,3,26,1631821,16,1310721,2,5,
+26,2,1310721,2,7,26,2,26,1310721,2,3,26,2,10,3,6,
+10,4,8,3,1632667,14,1310721,2,5,26,2,1310721,2,7,26,2,
+26,2,1310721,2,3,26,2,1630621,12,1632667,14,1310721,2,3,26,1310721,
+2,3,26,2,1630307,12,10,3,6,10,4,8,1310721,2,2,1,
+26,2,11,28,1,6,1,10,28,34,63,38,3,26,1632003,16,
+1310721,2,3,26,2,1,26,2,11,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1632005,
+14,1,1632107,16,1310721,2,3,26,2,9,26,2,1584975,2,28,1,
+6,1,10,28,34,63,38,3,26,1632061,16,3,1632667,14,1310721,2,
+2,9,26,2,1310721,2,3,26,2,9,26,2,1310721,2,5,26,
+2,1631591,12,1632667,14,1310721,2,2,1,26,2,17,28,1,6,1,
+10,28,34,63,38,3,26,1632185,16,1310721,2,2,11,26,2,1,
+6,1,10,28,34,63,38,1,10,28,1632187,14,1,1632257,16,1310721,
+2,3,26,2,1,26,2,17,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1632259,14,
+1,1632339,16,1310721,2,3,26,2,11,26,2,1310721,2,2,11,26,
+2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1632341,14,1,1632641,16,1310721,2,11,26,
+1310721,2,2,13,26,2,10,3,6,10,4,8,1310721,2,13,26,
+1310721,2,3,26,2,13,26,2,10,3,6,10,4,8,1310721,2,
+9,26,1310721,2,11,26,2,1,26,2,10,3,6,10,4,8,
+1310721,2,7,26,1,10,3,6,10,4,8,1310721,2,7,26,2,
+1310721,2,9,26,2,40,1632635,16,1310721,2,11,26,2,3,1310721,2,
+7,26,2,26,26,2,1310721,2,13,26,2,3,1310721,2,7,26,
+2,26,26,2,1310721,2,5,26,2,1631591,12,1,6,1,10,28,
+34,63,38,3,26,1632597,16,1,1632667,14,1310721,2,7,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1632471,14,3,1632667,14,
+1310721,2,2,1310721,2,3,26,2,1630621,12,1632667,14,1,1310721,2,15,
+26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1632715,16,
+1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1,26,2,1310721,2,
+3,26,4,1310721,2,3,26,2,11,28,1,6,1,10,28,34,
+63,38,3,26,1632809,16,85,1573101,12,8,1310721,2,2,9,26,2,
+1632681,12,1633911,14,1310721,2,3,26,2,13,28,1,6,1,10,28,
+34,63,38,3,26,1632901,16,183,1573101,12,8,1310721,2,2,7,26,
+2,1573503,12,8,187,1573101,12,8,1310721,2,2,9,26,2,1632681,12,
+1633911,14,1310721,2,3,26,2,15,28,1,6,1,10,28,34,63,
+38,3,26,1633561,16,1632951,14,102,110,40,0,1632943,1573341,12,8,1310721,
+2,5,26,1,10,3,6,10,4,8,1310721,2,5,26,2,1310721,
+2,2,7,26,2,40,1633333,16,1310721,2,5,26,2,1633041,16,1633033,
+14,44,32,0,1633027,1573341,12,8,1310721,2,2,15,1310721,2,5,26,
+2,26,26,2,1632681,12,8,1310721,2,5,26,2,25,40,1633159,16,
+1310721,2,2,1310721,2,5,26,2,1646457,12,3,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1633161,14,1,1633183,16,1633175,14,46,109,0,1633169,1573341,12,8,1310721,
+2,5,26,2,25,40,1633271,16,1310721,2,2,1310721,2,5,26,2,
+1646457,12,5,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1633273,14,1,1633295,16,1633287,14,
+46,100,0,1633281,1573341,12,8,1310721,2,5,26,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1632981,14,83,1573101,12,8,1310721,2,
+2,9,26,2,1584975,2,28,1,6,1,10,28,34,63,38,1,
+10,28,1633391,16,3,1633429,14,1310721,2,2,11,26,2,3,32,1,
+6,1,10,28,34,63,38,1,10,28,1633555,16,1633447,14,32,45,
+62,32,0,1633437,1573341,12,8,1310721,2,2,9,26,2,1584975,2,28,
+1,6,1,10,28,34,63,38,1,10,28,1633517,16,1310721,2,2,
+9,26,2,1632681,12,8,1310721,2,2,11,26,2,3,32,1633555,16,
+1633547,14,46,117,0,1633541,1573341,12,8,1,1633911,14,1310721,2,2,5,
+26,2,1633599,16,1310721,2,2,5,26,2,1573341,12,8,1633615,14,1633607,
+14,63,0,1633603,1573341,12,8,1310721,2,3,26,2,17,28,1,6,
+1,10,28,34,63,38,3,26,1633691,16,1310721,2,2,11,26,2,
+1,6,1,10,28,34,63,38,1,10,28,1633693,14,1,1633903,16,
+1310721,2,7,26,1310721,2,2,13,26,2,10,3,6,10,4,8,
+121,1573101,12,8,1310721,2,5,26,1,10,3,6,10,4,8,1310721,
+2,5,26,2,1310721,2,7,26,2,1,26,2,40,1633895,16,1310721,
+2,5,26,2,1633823,16,1633815,14,44,32,0,1633809,1573341,12,8,1310721,
+2,7,26,2,3,1310721,2,5,26,2,26,26,2,1632681,12,8,
+1310721,2,5,26,1,6,2,1,6,3,26,5,6,4,10,8,
+8,1633759,14,125,1573101,12,8,1,1633911,14,1,1310721,2,9,26,1310721,
+4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1633959,16,1966081,1310721,
+4,1579069,12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,
+1584985,2,1,6,1,10,28,34,63,38,3,26,1634019,16,3,1634065,
+14,1584857,2,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1634075,16,3,1634101,14,1584991,2,1,
+6,1,10,28,34,63,38,1,10,28,1634111,16,3,1634137,14,1585091,
+2,1,6,1,10,28,34,63,38,1,10,28,1634147,16,1,1634311,
+14,1585093,12,8,1634183,14,116,121,112,101,32,101,114,114,111,114,
+58,32,0,1634157,1573341,12,8,1310721,2,2,1573341,12,8,1634231,14,58,
+32,101,120,112,101,99,116,101,100,32,0,1634207,1573341,12,8,1310721,
+2,3,26,2,1632681,12,8,1634273,14,44,32,103,111,116,32,0,
+1634259,1573341,12,8,1310721,2,5,26,2,1632681,12,8,1585237,12,8,1,
+1634311,14,1,1310721,2,7,26,1310721,4,18,1310721,2,7,28,1310721,4,
+1310721,2,1835009,40,1634359,16,1966081,1310721,4,1579069,12,1310721,2,5,26,4,
+1310721,2,3,26,4,1310721,2,4,1310721,2,2,1634401,16,3,1634447,14,
+1584985,2,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1634457,16,3,1634503,14,1584857,2,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1634513,16,3,1634539,14,1584991,2,1,6,1,10,28,34,
+63,38,1,10,28,1634549,16,3,1634575,14,1585091,2,1,6,1,10,
+28,34,63,38,1,10,28,1634585,16,1,1634701,14,1585093,12,8,1634621,
+14,116,121,112,101,32,101,114,114,111,114,58,32,0,1634595,1573341,
+12,8,1310721,2,3,26,2,1573341,12,8,1634663,14,44,32,103,111,
+116,32,0,1634649,1573341,12,8,1310721,2,5,26,2,1632681,12,8,1585237,
+12,8,1,1634701,14,1,1310721,2,7,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1634749,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1585009,2,1310721,2,3,26,4,1310721,2,3,26,2,1634883,16,1310721,
+2,3,26,1,6,2,1,6,-1,26,5,6,4,10,8,8,
+1584993,1310721,2,3,26,2,26,2,1310721,2,2,28,1,6,1,10,
+28,34,63,38,3,26,1634879,16,1310721,2,3,26,2,1634897,14,1634769,
+14,3,1,10,28,1634897,14,1,1310721,2,5,26,1310721,4,18,1310721,
+2,5,28,1310721,4,1310721,2,1835009,40,1634945,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,1634715,12,1,40,3,36,1634979,16,3,1635133,
+14,1310721,2,2,1603687,12,1,40,3,36,1635007,16,1,1635133,14,1310721,
+2,3,26,1310721,2,2,1587809,12,10,3,6,10,4,8,1310721,2,
+3,26,2,1,40,3,36,1635125,16,1417729,1310721,2,3,26,2,26,
+2,15,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1635127,14,1,1635133,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1635181,
+16,1966081,1310721,4,1579069,12,1585019,2,1598497,12,1635217,16,1582579,1585017,2,10,
+3,6,10,4,8,1,1635235,14,1585017,2,1599031,12,8,1,1635235,14,
+1,1310721,2,1,26,1310721,4,18,1310721,2,79,28,1310721,4,1310721,2,
+1835009,40,1635283,16,1966081,1310721,4,1579069,12,1,1310721,2,7,26,4,1,
+1310721,2,75,26,4,1584911,2,1598801,12,1635331,16,1635249,12,1624435,12,1637129,
+14,1584895,2,1598801,12,1635495,16,1310721,2,1665803,12,10,3,6,10,4,
+8,1584897,2,1599031,12,8,1310721,2,5,26,1635249,12,10,3,6,10,
+4,8,1310721,2,2,1,40,1635471,16,1635463,14,97,32,110,101,103,
+97,116,105,118,101,32,97,114,114,97,121,32,108,101,110,103,
+116,104,0,1635415,1585679,12,8,1310721,2,5,26,2,1310721,2,2,1624809,
+12,1637129,14,1584927,2,1598649,12,1636065,16,1597071,12,8,1584887,2,1599031,12,
+8,1584889,2,1598497,12,1,6,1,10,28,34,63,38,3,26,1635745,
+16,3,1635745,16,1310721,2,7,26,2,49,40,3,36,1635635,16,1635627,
+14,116,111,111,32,109,97,110,121,32,112,97,114,97,109,101,
+116,101,114,115,0,1635587,1586063,12,8,1310721,2,9,26,1310721,2,7,
+26,2,26,1635249,12,10,3,6,10,4,8,1310721,2,7,26,1,
+6,2,1,6,3,26,5,6,4,10,8,8,1584899,2,1598801,12,
+1,6,1,10,28,34,63,38,3,26,1635741,16,1635745,14,1635555,14,
+1584889,2,1599031,12,8,1310721,2,57,26,1584975,2,10,3,6,10,4,
+8,1310721,2,77,26,1,10,3,6,10,4,8,1584905,2,1598801,12,
+1635995,16,1584925,2,1598497,12,1,6,1,10,28,34,63,38,3,26,
+1635869,16,1310721,2,57,26,1635249,12,10,3,6,10,4,8,1584925,2,
+1598801,12,1635995,16,1584945,2,1598649,12,1,6,1,10,28,34,63,38,
+3,26,1635967,16,1635959,14,116,104,101,32,114,101,116,117,114,110,
+32,116,97,103,32,105,115,32,46,117,0,1635917,1586063,12,8,1597071,
+12,8,1310721,2,77,26,3,10,3,6,10,4,8,1310721,2,57,
+26,2,1310721,2,7,26,2,1310721,2,9,26,1310721,2,77,26,2,
+1310721,2,7,26,2,26,1310721,2,7,26,2,26,1625329,12,1637129,14,
+1582577,2,5,28,1,6,1,10,28,34,63,38,1,10,28,1636151,
+16,1636135,14,101,120,112,101,99,116,101,100,32,97,32,116,121,
+112,101,0,1636103,1586063,12,8,1584975,2,1637129,14,1310721,2,1582579,2,10,
+3,6,10,4,8,1310721,2,77,26,1310721,2,2,1634715,12,10,3,
+6,10,4,8,1310721,2,77,26,2,1,40,3,36,1636253,16,1597071,
+12,8,1310721,2,77,26,2,1310721,2,2,1626251,12,1637129,14,1310721,2,
+3,26,1310721,2,2,1587809,12,10,3,6,10,4,8,1310721,2,3,
+26,2,1,40,1636307,16,3,1636371,14,1417729,1310721,2,3,26,2,26,
+2,15,28,1,6,1,10,28,34,63,38,1,10,28,1,6,
+1,10,28,34,63,38,1,10,28,1636427,16,1310721,2,2,1636411,14,
+105,115,110,39,116,32,97,32,116,121,112,101,0,1636385,1586197,12,
+8,1584975,2,1637129,14,1597071,12,8,1310721,2,5,26,1425921,1310721,2,3,
+26,2,26,2,10,3,6,10,4,8,1310721,2,5,26,2,1,
+26,2,21,28,1,6,1,10,28,34,63,38,1,10,28,1636529,
+16,1310721,2,5,26,2,1637129,14,1585015,2,1599031,12,8,3,1636951,16,
+1310721,2,75,26,2,17,40,3,36,1636627,16,1636619,14,116,111,111,
+32,109,97,110,121,32,116,121,112,101,32,97,114,103,117,109,
+101,110,116,115,0,1636571,1586063,12,8,1310721,2,59,26,1310721,2,75,
+26,2,26,1635249,12,10,3,6,10,4,8,1310721,2,59,26,1310721,
+2,75,26,2,26,2,1628577,12,3,28,1,6,1,10,28,34,
+63,38,1,10,28,1636877,16,1636869,14,116,121,112,101,32,97,114,
+103,117,109,101,110,116,115,32,104,97,118,101,32,116,111,32,
+98,101,32,111,110,101,32,119,111,114,100,32,40,97,32,112,
+111,105,110,116,101,114,44,32,97,32,110,117,109,98,101,114,
+44,32,111,114,32,97,32,112,97,114,97,109,101,116,101,114,
+41,0,1636723,1585679,12,8,1310721,2,75,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1584899,2,1598801,12,1,6,1,10,28,
+34,63,38,3,26,1636947,16,1636951,14,1636539,14,1635147,12,8,1310721,2,
+75,26,2,1310721,2,5,26,2,7,26,2,28,1,6,1,10,
+28,34,63,38,1,10,28,1637091,16,1310721,2,2,1637083,14,119,114,
+111,110,103,32,110,117,109,98,101,114,32,111,102,32,116,121,
+112,101,32,97,114,103,117,109,101,110,116,115,0,1637021,1585849,12,
+8,1310721,2,5,26,2,1310721,2,59,26,1310721,2,75,26,2,1626643,
+12,1637129,14,1,1310721,2,79,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1637177,16,1966081,1310721,4,1579069,12,1582577,2,9,28,
+1,6,1,10,28,34,63,38,3,26,1637815,16,1582579,2,1584895,2,
+28,1,6,1,10,28,34,63,38,3,26,1637249,16,3,1637301,14,
+1582579,2,1584925,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1637311,16,3,1637931,14,1582579,
+2,1584911,2,28,1,6,1,10,28,34,63,38,3,26,1637809,16,
+1310721,2,1,10,3,6,10,4,8,1310721,2,2,7,40,1637541,16,
+1310721,2,2,1597469,12,8,1584799,2,9,28,1,6,1,10,28,34,
+63,38,3,26,1637477,16,1584801,2,1584911,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1637479,14,1,1,6,1,10,28,34,63,38,3,26,1637507,16,1637541,
+14,1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1637363,14,1310721,2,2,1597469,12,8,1584799,2,5,28,1,6,1,10,
+28,34,63,38,3,26,1637681,16,1584801,2,1634911,12,1637603,16,3,1637655,
+14,1584801,2,1584927,2,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1,6,1,10,28,
+34,63,38,1,10,28,1637683,14,1,1637693,16,3,1637805,14,1584799,2,
+9,28,1,6,1,10,28,34,63,38,3,26,1637781,16,1584801,2,
+1584895,2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1637783,14,1,1,6,1,10,28,
+34,63,38,1,10,28,1637931,14,1,1637931,14,1582577,2,5,28,1,
+6,1,10,28,34,63,38,1,10,28,1637855,16,1,1637931,14,1582579,
+2,1584927,2,28,1,6,1,10,28,34,63,38,3,26,1637895,16,
+3,1637925,14,1582579,2,1634911,12,1,6,1,10,28,34,63,38,1,
+10,28,1637931,14,1,1310721,2,3,26,1310721,4,18,1310721,2,1,28,
+1310721,4,1310721,2,1835009,40,1637979,16,1966081,1310721,4,1579069,12,1585011,1,10,
+3,6,10,4,8,1585013,1,10,3,6,10,4,8,1584925,2,1598497,
+12,1,6,1,10,28,34,63,38,3,26,1638061,16,1585011,1635249,12,
+10,3,6,10,4,8,1584925,2,1598801,12,1638297,16,1582579,2,1584941,2,
+28,1,6,1,10,28,34,63,38,3,26,1638127,16,1585013,3,10,
+3,6,10,4,8,1638291,14,1582579,2,1584945,2,28,1,6,1,10,
+28,34,63,38,3,26,1638181,16,1585013,5,10,3,6,10,4,8,
+1638291,14,1582579,2,1584943,2,28,1,6,1,10,28,34,63,38,3,
+26,1638235,16,1585013,7,10,3,6,10,4,8,1638291,14,1638283,14,97,
+32,116,97,103,32,105,115,32,46,117,44,32,46,109,32,111,
+114,32,46,100,0,1638239,1586063,12,8,1597071,12,8,1,1638305,14,1,
+1310721,2,1,26,1310721,4,18,1310721,2,21,28,1310721,4,1310721,2,1835009,
+40,1638353,16,1966081,1310721,4,1579069,12,1,1310721,2,7,26,4,1524225,1310721,
+2,9,26,4,1,1310721,2,15,26,4,1,1310721,2,17,26,4,
+1597071,12,8,1310721,2,1599321,12,10,3,6,10,4,8,1585015,2,1598497,
+12,1638821,16,1597071,12,8,1585009,1,10,3,6,10,4,8,3,1638637,
+16,1585009,2,17,40,3,36,1638545,16,1638537,14,116,111,111,32,109,
+97,110,121,32,116,121,112,101,32,112,97,114,97,109,101,116,
+101,114,115,0,1638487,1586063,12,8,1584993,1585009,2,26,1599321,12,10,3,
+6,10,4,8,1585009,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1584899,2,1598801,12,1,6,1,10,28,34,63,38,3,26,
+1638633,16,1638637,14,1638461,14,1635147,12,8,1310721,2,17,26,3,10,3,
+6,10,4,8,1310721,2,3,26,21,1,1310721,2,2,1,1624087,12,
+10,3,6,10,4,8,1310721,2,3,26,2,7,26,1585009,2,10,
+3,6,10,4,8,1310721,2,13,26,1585009,2,1623873,12,10,3,6,
+10,4,8,1310721,2,13,26,2,1584993,1585009,2,1574337,12,8,1310721,2,
+3,26,2,13,26,1310721,2,13,26,2,10,3,6,10,4,8,
+1638891,14,1310721,2,3,26,17,1,1310721,2,2,1,1624087,12,10,3,
+6,10,4,8,1310721,2,3,26,2,7,26,5,1,10,28,10,
+3,6,10,4,8,1310721,2,5,26,1310721,2,2,15,1310721,2,3,
+26,2,1587311,12,10,3,6,10,4,8,1584891,2,1599031,12,8,1584893,
+2,1598497,12,1,6,1,10,28,34,63,38,3,26,1639269,16,1310721,
+2,19,26,1635249,12,10,3,6,10,4,8,3,1639255,16,1310721,2,
+7,26,2,2001,40,3,36,1639071,16,1639063,14,116,111,111,32,109,
+97,110,121,32,102,105,101,108,100,115,0,1639031,1585585,12,8,1310721,
+2,9,26,2,1310721,2,7,26,2,1310721,2,7,26,2,26,26,
+1599321,12,10,3,6,10,4,8,1310721,2,9,26,2,1310721,2,7,
+26,2,1310721,2,7,26,2,26,3,26,26,1310721,2,19,26,2,
+10,3,6,10,4,8,1310721,2,7,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1584899,2,1598801,12,1,6,1,10,28,
+34,63,38,3,26,1639251,16,1639255,14,1638999,14,1584901,2,1599031,12,8,
+1638943,14,1597071,12,8,1310721,2,17,26,2,1639475,16,1310721,2,13,26,
+1310721,2,7,26,2,1310721,2,7,26,2,26,1623873,12,10,3,6,
+10,4,8,1310721,2,13,26,2,1310721,2,9,26,2,1310721,2,7,
+26,2,1310721,2,7,26,2,26,1574337,12,8,1310721,2,3,26,2,
+9,26,1310721,2,13,26,2,10,3,6,10,4,8,1310721,2,3,
+26,2,11,26,1310721,2,7,26,2,10,3,6,10,4,8,1585009,
+1,10,3,6,10,4,8,1640185,14,1310721,2,13,26,1310721,2,7,
+26,2,7,30,3,26,1623873,12,10,3,6,10,4,8,1310721,2,
+11,26,1,10,3,6,10,4,8,1310721,2,11,26,2,1310721,2,
+7,26,2,40,1640077,16,1310721,2,19,26,1310721,2,9,26,2,1310721,
+2,11,26,2,1310721,2,11,26,2,26,3,26,26,2,10,3,
+6,10,4,8,1310721,2,19,26,2,1310721,2,3,26,2,28,1,
+6,1,10,28,34,63,38,3,26,1639815,16,1639783,14,97,32,115,
+116,114,117,99,116,32,99,97,110,39,116,32,99,111,110,116,
+97,105,110,32,105,116,115,101,108,102,32,98,121,32,118,97,
+108,117,101,59,32,117,115,101,32,97,32,112,111,105,110,116,
+101,114,0,1639675,1585679,12,8,1310721,2,19,26,1584975,2,10,3,6,
+10,4,8,1310721,2,13,26,2,1310721,2,11,26,2,7,30,26,
+1310721,2,9,26,2,1310721,2,11,26,2,1310721,2,11,26,2,26,
+26,2,10,3,6,10,4,8,1310721,2,13,26,2,1310721,2,11,
+26,2,7,30,3,26,26,1310721,2,19,26,2,10,3,6,10,
+4,8,1310721,2,13,26,2,1310721,2,11,26,2,7,30,5,26,
+26,1310721,2,15,26,2,10,3,6,10,4,8,1310721,2,15,26,
+1310721,2,15,26,2,1310721,2,19,26,2,1628577,12,26,10,3,6,
+10,4,8,1310721,2,11,26,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1639539,14,1310721,2,3,26,2,9,26,1310721,2,13,
+26,2,10,3,6,10,4,8,1310721,2,3,26,2,3,26,1310721,
+2,15,26,2,10,3,6,10,4,8,1310721,2,3,26,2,7,
+26,1310721,2,7,26,2,10,3,6,10,4,8,1584901,2,1598801,12,
+8,1310721,2,5,26,2,1640211,14,1,1310721,2,21,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1640259,16,1966081,1310721,4,1579069,
+12,1597071,12,8,1310721,2,1599321,12,10,3,6,10,4,8,1584903,2,
+1599031,12,8,1310721,2,2,15,1635249,12,1587311,12,8,1584901,2,1599031,12,
+8,1,1640331,14,1,1310721,2,3,26,1310721,4,18,1310721,2,1,28,
+1310721,4,1310721,2,1835009,40,1640379,16,1966081,1310721,4,1579069,12,1597071,12,8,
+1585037,2,1598649,12,1640417,16,1584985,3,10,3,6,10,4,8,1640521,14,
+1585039,2,1598649,12,1640449,16,1584985,1,10,3,6,10,4,8,1640521,14,
+1640513,14,116,121,112,101,99,104,101,99,107,32,111,110,32,111,
+114,32,116,121,112,101,99,104,101,99,107,32,111,102,102,0,
+1640453,1586063,12,8,1597071,12,8,1584901,2,1599031,12,8,1,1640545,14,1,
+1310721,2,1,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,
+40,1640593,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,
+1,1310721,2,5,26,4,1310721,2,2,1627505,12,8,1310721,2,5,26,
+2,1310721,2,2,7,26,2,40,1640779,16,1310721,2,2,9,26,2,
+1310721,2,5,26,2,7,30,26,2,1310721,2,3,26,2,28,1,
+6,1,10,28,34,63,38,3,26,1640741,16,1310721,2,5,26,2,
+1640793,14,1310721,2,5,26,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1640633,14,3,1,10,28,1640793,14,1,1310721,2,7,26,
+1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1640841,16,1966081,
+1310721,4,1579069,12,1584887,2,1599031,12,8,1637143,12,1640913,16,1584925,2,1598497,
+12,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1640915,14,1,1640943,16,1310721,2,1635249,12,10,
+3,6,10,4,8,1641105,14,1310721,2,3,26,1606761,12,10,3,6,
+10,4,8,1584991,1,6,2,1,6,3,26,5,6,4,10,8,
+8,1310721,2,5,26,1662195,12,10,3,6,10,4,8,1647757,12,8,
+1310721,2,1584987,2,10,3,6,10,4,8,1584991,1,6,2,1,6,
+-1,26,5,6,4,10,8,8,1310721,2,3,26,2,1607393,12,8,
+1310721,2,3,26,2,1607311,12,8,1584889,2,1599031,12,8,1310721,2,2,
+1641127,14,1,1310721,2,7,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1641175,16,1966081,1310721,4,1579069,12,1597071,12,8,1310721,2,
+1640807,12,10,3,6,10,4,8,1310721,2,2,1628577,12,1589149,12,8,
+1584987,1584977,2,10,3,6,10,4,8,1,1641243,14,1,1310721,2,3,
+26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1641291,16,
+1966081,1310721,4,1579069,12,1597071,12,8,1310721,2,1640807,12,10,3,6,10,
+4,8,1310721,2,2,1589149,12,8,1584987,1584975,2,10,3,6,10,4,
+8,1,1641355,14,1,1310721,2,3,26,1310721,4,18,1310721,2,1,28,
+1310721,4,1310721,2,1835009,40,1641403,16,1966081,1310721,4,1579069,12,1584971,1277953,2049,
+26,10,3,6,10,4,8,1584973,1,10,3,6,10,4,8,1584975,
+1,3,1641459,14,119,111,114,100,0,1641449,1586793,12,1,1624087,12,10,
+3,6,10,4,8,1584977,3,3,1641501,14,105,110,116,0,1641493,1586793,
+12,1,1624087,12,10,3,6,10,4,8,1584979,5,3,1641545,14,99,
+104,97,114,0,1641535,1586793,12,1,1624087,12,10,3,6,10,4,8,
+1584981,7,3,1641589,14,98,111,111,108,0,1641579,1586793,12,1,1624087,12,
+10,3,6,10,4,8,1584983,9,1,1641633,14,118,111,105,100,0,
+1641623,1586793,12,1,1624087,12,10,3,6,10,4,8,1584975,2,5,26,
+2,15,1584975,2,1587311,12,8,1584977,2,5,26,2,15,1584977,2,1587311,
+12,8,1584979,2,5,26,2,15,1584979,2,1587311,12,8,1584981,2,5,
+26,2,15,1584981,2,1587311,12,8,1584983,2,5,26,2,15,1584983,2,
+1587311,12,8,1585015,1641777,14,60,0,1641773,1586793,12,10,3,6,10,4,
+8,1585017,1641805,14,62,0,1641801,1586793,12,10,3,6,10,4,8,1585019,
+1641835,14,62,62,0,1641829,1586793,12,10,3,6,10,4,8,1585021,1641865,
+14,60,61,0,1641859,1586793,12,10,3,6,10,4,8,1585023,1641895,14,
+62,61,0,1641889,1586793,12,10,3,6,10,4,8,1585025,1641925,14,61,
+61,0,1641919,1586793,12,10,3,6,10,4,8,1585027,1641955,14,33,61,
+0,1641949,1586793,12,10,3,6,10,4,8,1585029,1641983,14,43,0,1641979,
+1586793,12,10,3,6,10,4,8,1585031,1642021,14,115,116,114,117,99,
+116,0,1642007,1586793,12,10,3,6,10,4,8,1585033,1642055,14,116,121,
+112,101,0,1642045,1586793,12,10,3,6,10,4,8,1585035,1642099,14,116,
+121,112,101,99,104,101,99,107,0,1642079,1586793,12,10,3,6,10,
+4,8,1585037,1642129,14,111,110,0,1642123,1586793,12,10,3,6,10,4,
+8,1585039,1642161,14,111,102,102,0,1642153,1586793,12,10,3,6,10,4,
+8,1585041,1642193,14,110,101,119,0,1642185,1586793,12,10,3,6,10,4,
+8,1585043,1642229,14,110,101,119,95,116,0,1642217,1586793,12,10,3,6,
+10,4,8,1585045,1,26,1642261,14,42,0,1642257,1586793,12,10,3,6,
+10,4,8,1585045,3,26,1642293,14,47,0,1642289,1586793,12,10,3,6,
+10,4,8,1585045,5,26,1642325,14,37,0,1642321,1586793,12,10,3,6,
+10,4,8,1585045,7,26,1642357,14,38,0,1642353,1586793,12,10,3,6,
+10,4,8,1585045,9,26,1642389,14,124,0,1642385,1586793,12,10,3,6,
+10,4,8,1585045,11,26,1642421,14,94,0,1642417,1586793,12,10,3,6,
+10,4,8,1585045,13,26,1642455,14,60,60,0,1642449,1586793,12,10,3,
+6,10,4,8,1585045,15,26,1585019,2,10,3,6,10,4,8,1585069,
+17,10,3,6,10,4,8,1,1642519,14,1,1310721,2,1,26,1310721,
+4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1642567,16,1966081,1310721,
+4,1579069,12,1310721,2,4,1,1310721,2,3,26,4,1310721,2,3,26,
+2,1585069,2,40,1642697,16,1585045,1310721,2,3,26,2,26,2,1310721,2,
+2,28,1,6,1,10,28,34,63,38,3,26,1642659,16,3,1642705,
+14,1310721,2,3,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1642585,14,1,1642705,14,1,1310721,2,5,26,1310721,4,18,1310721,
+2,9,28,1310721,4,1310721,2,1835009,40,1642753,16,1966081,1310721,4,1579069,12,
+1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,1546753,1310721,2,
+2,26,2,1310721,2,7,26,4,1310721,2,3,26,1310721,2,3,26,
+2,1630307,12,10,3,6,10,4,8,1310721,2,5,26,1310721,2,5,
+26,2,1630307,12,10,3,6,10,4,8,1547137,1310721,2,2,26,2,
+1,40,1643065,16,1310721,2,3,26,2,1629979,12,1,6,1,10,28,
+34,63,38,3,26,1642987,16,1310721,2,5,26,2,1629979,12,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1642989,14,1,1643039,14,38,38,32,97,110,100,32,124,
+124,32,110,101,101,100,32,115,99,97,108,97,114,115,0,1642993,
+1310721,2,3,26,2,1634325,12,8,1584981,2,1645491,14,1310721,2,7,26,
+2,1585025,2,28,1,6,1,10,28,34,63,38,3,26,1643111,16,
+3,1643169,14,1310721,2,7,26,2,1585027,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1643359,16,1310721,2,3,26,2,1310721,2,5,26,2,1630621,12,1,6,
+1,10,28,34,63,38,3,26,1643291,16,1310721,2,5,26,2,1310721,
+2,3,26,2,1630621,12,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1643293,14,1,1643351,16,
+1643323,14,99,111,109,112,97,114,105,115,111,110,0,1643301,1310721,2,
+3,26,2,1310721,2,5,26,2,1633925,12,8,1584981,2,1645491,14,1310721,
+2,7,26,2,1585015,2,28,1,6,1,10,28,34,63,38,3,
+26,1643405,16,3,1643463,14,1310721,2,7,26,2,1585017,2,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1643473,16,3,1643531,14,1310721,2,7,26,2,1585021,2,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1643541,16,3,1643599,14,1310721,2,7,26,2,1585023,
+2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1644029,16,1310721,2,3,26,2,1584975,2,
+28,1,6,1,10,28,34,63,38,3,26,1643649,16,3,1643707,14,
+1310721,2,5,26,2,1584975,2,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1643717,16,3,
+1643799,14,1310721,2,3,26,2,1629747,12,1643775,16,1310721,2,5,26,2,
+1629747,12,1,6,1,10,28,34,63,38,1,10,28,1643777,14,1,
+1,6,1,10,28,34,63,38,1,10,28,1643809,16,3,1643943,14,
+1310721,2,3,26,2,1,26,2,11,28,1,6,1,10,28,34,
+63,38,3,26,1643919,16,1310721,2,5,26,2,1,26,2,11,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1643921,14,1,1,6,1,10,28,34,63,38,
+1,10,28,1,6,1,10,28,34,63,38,3,26,1644021,16,1643993,
+14,99,111,109,112,97,114,105,115,111,110,0,1643971,1310721,2,3,
+26,2,1310721,2,5,26,2,1633925,12,8,1584981,2,1645491,14,1310721,2,
+7,26,2,1585029,2,28,1,6,1,10,28,34,63,38,3,26,
+1644577,16,1310721,2,3,26,2,1,26,2,11,28,1,6,1,10,
+28,34,63,38,3,26,1644221,16,1310721,2,5,26,2,1629747,12,1644137,
+16,3,1644195,14,1310721,2,5,26,2,1584975,2,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1,6,1,10,28,34,63,38,1,10,28,1644223,14,1,1644241,
+16,1310721,2,3,26,2,1645491,14,1310721,2,5,26,2,1,26,2,
+11,28,1,6,1,10,28,34,63,38,3,26,1644325,16,1310721,2,
+3,26,2,1629747,12,1,6,1,10,28,34,63,38,1,10,28,
+1644327,14,1,1644345,16,1310721,2,5,26,2,1645491,14,1310721,2,3,26,
+2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,1644391,16,
+3,1644449,14,1310721,2,5,26,2,1584975,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1644461,16,1584975,2,1645491,14,1310721,2,3,26,2,1629747,12,1644519,16,1310721,
+2,5,26,2,1629747,12,1,6,1,10,28,34,63,38,1,10,
+28,1644521,14,1,1644533,16,1584977,2,1645491,14,1644541,14,43,0,1644537,1310721,
+2,3,26,2,1310721,2,5,26,2,1633925,12,8,1584975,2,1645491,14,
+1310721,2,7,26,2,1584919,2,28,1,6,1,10,28,34,63,38,
+3,26,1645145,16,1310721,2,3,26,2,1,26,2,11,28,1,6,
+1,10,28,34,63,38,3,26,1644727,16,1310721,2,5,26,2,1,
+26,2,11,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1644729,14,1,1644741,16,1584977,2,
+1645491,14,1310721,2,3,26,2,1,26,2,11,28,1,6,1,10,
+28,34,63,38,3,26,1644893,16,1310721,2,5,26,2,1629747,12,1644809,
+16,3,1644867,14,1310721,2,5,26,2,1584975,2,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1,6,1,10,28,34,63,38,1,10,28,1644895,14,1,1644913,
+16,1310721,2,3,26,2,1645491,14,1310721,2,3,26,2,1584975,2,28,
+1,6,1,10,28,34,63,38,3,26,1644959,16,3,1645017,14,1310721,
+2,5,26,2,1584975,2,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1645029,16,1584975,2,
+1645491,14,1310721,2,3,26,2,1629747,12,1645087,16,1310721,2,5,26,2,
+1629747,12,1,6,1,10,28,34,63,38,1,10,28,1645089,14,1,
+1645101,16,1584977,2,1645491,14,1645109,14,45,0,1645105,1310721,2,3,26,2,
+1310721,2,5,26,2,1633925,12,8,1584975,2,1645491,14,1310721,2,7,26,
+2,1642533,12,1645481,16,1310721,2,3,26,2,1584975,2,28,1,6,1,
+10,28,34,63,38,3,26,1645209,16,3,1645267,14,1310721,2,5,26,
+2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1645279,16,1584975,2,1645491,14,1310721,
+2,3,26,2,1629747,12,1645337,16,1310721,2,5,26,2,1629747,12,1,
+6,1,10,28,34,63,38,1,10,28,1645339,14,1,1645351,16,1584977,
+2,1645491,14,1310721,2,3,26,2,1629747,12,1645399,16,1310721,2,3,26,
+1310721,2,5,26,2,10,3,6,10,4,8,1,1645455,14,97,114,
+105,116,104,109,101,116,105,99,32,110,101,101,100,115,32,110,
+117,109,98,101,114,115,0,1645405,1310721,2,3,26,2,1634325,12,8,
+1584975,2,1645491,14,1584975,2,1645491,14,1,1310721,2,9,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1645539,16,1966081,1310721,4,1579069,
+12,1310721,2,4,1310721,2,2,1,26,2,1645563,14,1,1310721,2,3,
+26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1645611,16,
+1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1628577,12,1645633,14,1,
+1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,
+40,1645681,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,5,26,
+2,1645705,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1645753,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,
+2,2,7,26,2,1645777,14,1,1310721,2,3,26,1310721,4,18,1310721,
+2,3,28,1310721,4,1310721,2,1835009,40,1645825,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,1627505,12,8,1310721,2,2,7,26,2,1645861,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1645909,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,
+2,4,1310721,2,2,1627505,12,8,1310721,2,2,9,26,2,1310721,2,
+3,26,2,7,30,26,2,1645973,14,1,1310721,2,5,26,1310721,4,
+18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1646021,16,1966081,1310721,4,
+1579069,12,1310721,2,3,26,4,1310721,2,4,1310721,2,2,1627505,12,8,
+1310721,2,2,9,26,2,1310721,2,3,26,2,7,30,3,26,26,
+2,1646089,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,1310721,
+4,1310721,2,1835009,40,1646137,16,1966081,1310721,4,1579069,12,1310721,2,3,26,
+4,1310721,2,4,1310721,2,2,1627505,12,8,1310721,2,2,9,26,2,
+1310721,2,3,26,2,7,30,5,26,26,2,1646205,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1646253,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,9,26,2,1646277,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,
+2,1835009,40,1646325,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,
+7,26,2,1646349,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1646397,16,1966081,1310721,4,1579069,12,1310721,2,
+3,26,4,1310721,2,4,1310721,2,2,15,1310721,2,3,26,2,26,
+26,2,1646443,14,1,1310721,2,5,26,1310721,4,18,1310721,2,5,28,
+1310721,4,1310721,2,1835009,40,1646491,16,1966081,1310721,4,1579069,12,1310721,2,3,
+26,4,1310721,2,4,1310721,2,2,11,26,2,13,38,1310721,2,3,
+26,2,1310721,2,3,26,2,26,38,7,32,1646557,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1646605,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,11,26,2,3,
+32,1646633,14,1,1310721,2,3,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1646681,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,
+2,2,1,26,2,17,28,1,6,1,10,28,34,63,38,1,
+10,28,1646735,16,3,1646789,14,1310721,2,2,11,26,2,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1646799,16,1,1646823,14,1310721,2,2,13,26,2,1,26,2,
+1646823,14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,
+1310721,2,1835009,40,1646871,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,
+1310721,2,4,1310721,2,2,13,26,2,3,1310721,2,3,26,2,26,
+26,2,1646923,14,1,1310721,2,5,26,1310721,4,18,1310721,2,59,28,
+1310721,4,1310721,2,1835009,40,1646971,16,1966081,1310721,4,1579069,12,1310721,2,4,
+1582507,2,1310721,2,3,26,4,3,1,10,28,1310721,2,5,26,4,
+1310721,2,3,26,2,1647267,16,1310721,2,3,26,1,6,2,1,6,
+-1,26,5,6,4,10,8,8,1417729,1310721,2,3,26,2,26,2,
+3,28,1,6,1,10,28,34,63,38,3,26,1647171,16,1425921,1310721,
+2,3,26,2,26,2,1310721,2,2,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1647173,
+14,1,1647223,16,1442305,1310721,2,3,26,2,26,2,3,32,1,6,
+1,10,28,34,63,38,1,10,28,1647225,14,1,1647263,16,1310721,2,
+5,26,1310721,2,3,26,2,10,3,6,10,4,8,1647267,14,1647009,
+14,1310721,2,5,26,2,1,40,1647291,16,1,1647545,14,1559041,1310721,2,
+5,26,2,26,2,1647331,16,1559041,1310721,2,5,26,2,26,2,1647545,
+14,1310721,2,55,26,1434113,1310721,2,5,26,2,26,2,3,38,63,
+32,10,3,6,10,4,8,1310721,2,57,26,1,10,3,6,10,
+4,8,1310721,2,57,26,2,1310721,2,55,26,2,40,1647497,16,1310721,
+2,7,26,1310721,2,57,26,2,26,1584975,2,10,3,6,10,4,
+8,1310721,2,57,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1647397,14,1584975,2,1310721,2,55,26,2,1310721,2,7,26,1434113,
+1310721,2,5,26,2,26,2,1625329,12,1647545,14,1,1310721,2,59,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1647593,16,1966081,
+1310721,4,1579069,12,1310721,2,4,1310721,2,2,1588311,12,1310721,2,3,26,
+4,1310721,2,3,26,2,1,40,1647643,16,3,1647707,14,1417729,1310721,2,
+3,26,2,26,2,3,28,1,6,1,10,28,34,63,38,1,
+10,28,1,6,1,10,28,34,63,38,1,10,28,1647717,16,1,
+1647743,14,1425921,1310721,2,3,26,2,26,2,1646937,12,1647743,14,1,1310721,
+2,5,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,
+1647791,16,1966081,1310721,4,1579069,12,1584875,2,1647855,16,1584987,2,1629979,12,1,
+6,1,10,28,34,63,38,3,26,1647839,16,3,1589235,12,8,1584875,
+1,10,3,6,10,4,8,1,1647863,14,1,1310721,2,1,26,1310721,
+4,18,1310721,2,11,28,1310721,4,1310721,2,1835009,40,1647911,16,1966081,1310721,
+4,1579069,12,1310721,2,3,26,4,1310721,2,4,1425921,1310721,2,2,26,
+2,1310721,2,5,26,4,1584881,2,1310721,2,7,26,4,1584881,1310721,2,
+3,26,2,10,3,6,10,4,8,1584883,1,10,3,6,10,4,
+8,1584987,1584975,2,10,3,6,10,4,8,1584989,1,10,3,6,10,
+4,8,1310721,2,5,26,2,1,6,12,10,8,8,1584881,1310721,2,
+7,26,2,10,3,6,10,4,8,1310721,2,9,26,1584883,2,10,
+3,6,10,4,8,1584875,1,10,3,6,10,4,8,1584877,1,10,
+3,6,10,4,8,1310721,2,9,26,2,1648155,14,1,1310721,2,11,
+26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1648203,16,
+1966081,1310721,4,1579069,12,1584881,2,1648303,16,1648295,14,116,104,105,115,32,
+99,97,110,39,116,32,98,101,32,117,115,101,100,32,105,110,
+115,105,100,101,32,97,110,32,101,120,112,114,101,115,115,105,
+111,110,0,1648215,1585679,12,8,1,1648311,14,1,1310721,2,1,26,1310721,
+4,18,1310721,2,13,28,1310721,4,1310721,2,1835009,40,1648359,16,1966081,1310721,
+4,1579069,12,1310721,2,5,26,4,1310721,2,3,26,4,1310721,2,4,
+1,1310721,2,7,26,4,1584887,2,1599031,12,8,1584889,2,1598497,12,1,
+6,1,10,28,34,63,38,3,26,1648831,16,3,1648831,16,1310721,2,
+9,26,1662195,12,10,3,6,10,4,8,1647757,12,8,1310721,2,9,
+26,2,1310721,2,2,1310721,2,7,26,2,1310721,2,7,26,2,26,
+38,7,32,1616761,12,8,1310721,2,3,26,2,1648593,16,1310721,2,7,
+26,2,1310721,2,3,26,2,7,26,2,40,1,6,1,10,28,
+34,63,38,1,10,28,1648595,14,1,1648757,16,1310721,2,11,26,1310721,
+2,3,26,2,15,1310721,2,7,26,2,26,26,2,10,3,6,
+10,4,8,1310721,2,11,26,2,1584987,2,1310721,2,5,26,2,1631591,
+12,1,6,1,10,28,34,63,38,3,26,1648757,16,1648721,14,97,
+114,103,117,109,101,110,116,0,1648703,1310721,2,11,26,2,1310721,2,
+5,26,2,1628749,12,1584987,2,1633925,12,8,1310721,2,7,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1584899,2,1598801,12,1,
+6,1,10,28,34,63,38,3,26,1648827,16,1648831,14,1648439,14,1584889,
+2,1599031,12,8,1310721,2,7,26,2,1648857,14,1,1310721,2,13,26,
+1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1648905,16,1966081,
+1310721,4,1579069,12,1310721,2,1635249,12,10,3,6,10,4,8,1584899,2,
+1598801,12,1649069,16,1310721,2,3,26,1662195,12,10,3,6,10,4,8,
+1647757,12,8,1310721,2,3,26,2,1605077,12,8,1310721,2,2,1628577,12,
+3,28,1,6,1,10,28,34,63,38,1,10,28,1649047,16,1310721,
+2,2,1628577,12,1589149,12,8,31,1589235,12,8,1310721,2,2,1,1624809,
+12,1589149,12,8,1649097,14,1310721,2,2,1628577,12,1589149,12,8,1310721,2,
+2,1589149,12,8,1584889,2,1599031,12,8,1585043,2,1589915,12,8,1584875,1,
+10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,1584987,1310721,
+2,2,1624435,12,10,3,6,10,4,8,1584989,1,10,3,6,10,
+4,8,3,1649197,14,1,1310721,2,5,26,1310721,4,18,1310721,2,27,
+28,1310721,4,1310721,2,1835009,40,1649245,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1,1310721,2,5,26,4,1,1310721,2,7,26,4,1559041,1310721,2,
+2,26,2,1310721,2,9,26,4,1409537,1310721,2,2,26,2,1585041,2,
+28,1,6,1,10,28,34,63,38,3,26,1649401,16,1417729,1310721,2,
+2,26,2,3,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1649403,14,1,1649731,16,1597931,
+12,8,1584799,2,9,28,1,6,1,10,28,34,63,38,3,26,
+1649563,16,1584801,2,1584911,2,28,1,6,1,10,28,34,63,38,3,
+26,1649485,16,3,1649537,14,1584801,2,1584895,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1,6,1,10,28,34,63,38,1,10,28,1649565,14,1,1649583,16,
+1597071,12,8,1648871,12,1650331,14,1584799,2,5,28,1,6,1,10,28,
+34,63,38,3,26,1649711,16,1584801,2,1634911,12,1649633,16,3,1649685,14,
+1584801,2,1584927,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,
+63,38,1,10,28,1649713,14,1,1649731,16,1597071,12,8,1648871,12,1650331,
+14,1442305,1310721,2,2,26,2,5,32,1649827,16,1310721,2,5,26,1434113,
+1310721,2,2,26,2,13,38,10,3,6,10,4,8,1310721,2,7,
+26,1434113,1310721,2,2,26,2,3,32,10,3,6,10,4,8,1649865,
+14,1442305,1310721,2,2,26,1442305,1310721,2,2,26,2,9,34,10,3,
+6,10,4,8,1310721,2,11,26,1,17,1574549,12,8,1585087,2,1649927,
+16,1310721,2,11,26,1585071,1585087,2,1574337,12,8,1585087,1,10,3,6,
+10,4,8,1310721,2,3,26,1310721,2,5,26,2,1310721,2,9,26,
+2,1310721,2,11,26,1648325,12,10,3,6,10,4,8,1442305,1310721,2,
+2,26,2,5,32,1650079,16,1310721,2,3,26,2,1434113,1310721,2,2,
+26,2,3,38,63,32,28,1,6,1,10,28,34,63,38,1,
+10,28,1,6,1,10,28,34,63,38,1,10,28,1650081,14,1,
+1650161,16,1409537,1310721,2,2,26,2,1650153,14,119,114,111,110,103,32,
+110,117,109,98,101,114,32,111,102,32,97,114,103,117,109,101,
+110,116,115,0,1650101,1585849,12,8,1310721,2,2,1589741,12,8,13,1589235,
+12,8,1584875,1,10,3,6,10,4,8,1584877,1,10,3,6,10,
+4,8,1584989,1,10,3,6,10,4,8,1584987,1584975,2,10,3,6,
+10,4,8,1310721,2,9,26,2,1650303,16,1584987,1310721,2,9,26,2,
+9,26,2,1310721,2,11,26,1628749,12,10,3,6,10,4,8,1310721,
+2,7,26,2,1650323,16,3,1650331,14,1,1650331,14,1,1310721,2,27,
+26,1310721,4,18,1310721,2,11,28,1310721,4,1310721,2,1835009,40,1650379,16,
+1966081,1310721,4,1579069,12,1310721,2,4,1434113,1310721,2,2,26,2,31,32,
+1310721,2,3,26,4,1434113,1310721,2,2,26,2,9,38,31,32,1310721,
+2,5,26,4,1,1310721,2,7,26,4,1584887,2,1599031,12,8,1584889,
+2,1598497,12,1,6,1,10,28,34,63,38,3,26,1650621,16,3,
+1650621,16,1310721,2,9,26,1662195,12,10,3,6,10,4,8,1647757,12,
+8,1310721,2,9,26,2,1605077,12,8,1310721,2,7,26,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1584899,2,1598801,12,1,6,
+1,10,28,34,63,38,3,26,1650617,16,1650621,14,1650495,14,1584889,2,
+1599031,12,8,1310721,2,7,26,2,1310721,2,3,26,2,28,1,6,
+1,10,28,34,63,38,1,10,28,1650749,16,1409537,1310721,2,2,26,
+2,1650741,14,119,114,111,110,103,32,110,117,109,98,101,114,32,
+111,102,32,105,110,112,117,116,115,0,1650695,1585849,12,8,1584875,1,
+10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,1584987,1584975,
+2,10,3,6,10,4,8,1584989,1,10,3,6,10,4,8,1442305,
+1310721,2,2,26,2,129,32,1650871,16,1450497,1310721,2,2,26,2,3,
+28,1589741,12,8,13,1589235,12,8,1,1651069,14,45,1425921,1310721,2,2,
+26,2,26,1589235,12,8,1310721,2,5,26,2,1,28,1,6,1,
+10,28,34,63,38,3,26,1650939,16,1,1589149,12,8,1310721,2,5,
+26,2,3,10,40,1651061,16,1409537,1310721,2,2,26,2,1651053,14,108,
+101,97,118,101,115,32,115,101,118,101,114,97,108,32,118,97,
+108,117,101,115,59,32,117,115,101,32,105,116,32,102,114,111,
+109,32,97,115,109,0,1650975,1585849,12,8,1,1651069,14,1,1310721,2,
+11,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1651117,
+16,1966081,1310721,4,1579069,12,1584875,1,10,3,6,10,4,8,1584877,1,
+10,3,6,10,4,8,1584989,1,10,3,6,10,4,8,1582577,2,
+3,28,1,6,1,10,28,34,63,38,3,26,1651279,16,1582579,2,
+1589149,12,8,1584989,1582579,2,1,28,1,6,1,10,28,34,63,38,
+3,26,10,3,6,10,4,8,1584987,1584977,2,10,3,6,10,4,
+8,1597071,12,8,1,1653909,14,1582577,2,7,28,1,6,1,10,28,
+34,63,38,3,26,1651355,16,1582579,2,1590177,12,8,1597071,12,8,1584987,
+1584979,2,1624435,12,10,3,6,10,4,8,1,1653909,14,1582577,2,9,
+28,1,6,1,10,28,34,63,38,3,26,1651607,16,1582579,2,1584887,
+2,28,1,6,1,10,28,34,63,38,3,26,1651475,16,1597071,12,
+8,1310721,2,7,26,1662195,12,10,3,6,10,4,8,1584889,2,1599031,
+12,8,1310721,2,7,26,2,1653909,14,1582579,2,1584891,2,28,1,6,
+1,10,28,34,63,38,3,26,1651517,16,1664235,12,1653909,14,1651567,14,
+101,120,112,101,99,116,101,100,32,97,110,32,101,120,112,114,
+101,115,115,105,111,110,0,1651521,1586063,12,8,1,1589149,12,8,1584987,
+1584975,2,10,3,6,10,4,8,1,1653909,14,1582577,2,5,28,1,
+6,1,10,28,34,63,38,1,10,28,1651731,16,1651691,14,101,120,
+112,101,99,116,101,100,32,97,110,32,101,120,112,114,101,115,
+115,105,111,110,0,1651645,1586063,12,8,1,1589149,12,8,1584987,1584975,2,
+10,3,6,10,4,8,1,1653909,14,1310721,2,1582579,2,10,3,6,
+10,4,8,1310721,2,3,26,1310721,2,2,1603687,12,10,3,6,10,
+4,8,1310721,2,3,26,2,1,40,3,36,1652203,16,1597071,12,8,
+1584853,2,1,6,1,10,28,34,63,38,3,26,1651877,16,1310721,2,
+3,26,2,1604491,12,1,6,1,10,28,34,63,38,1,10,28,
+1651879,14,1,1652027,16,1310721,2,2,1652019,14,105,115,32,116,114,97,
+99,107,101,100,32,98,121,32,116,104,101,32,97,110,97,108,
+121,122,101,114,32,97,110,100,32,99,97,110,39,116,32,98,
+101,32,117,115,101,100,32,105,110,32,117,110,99,104,101,99,
+107,101,100,32,99,111,100,101,0,1651893,1585849,12,8,1467905,1310721,2,
+3,26,2,26,2,1590069,12,8,1584987,1556993,1310721,2,3,26,2,26,
+2,10,3,6,10,4,8,1473025,1310721,2,3,26,2,26,2,1652105,
+16,1,1653909,14,1584875,3,10,3,6,10,4,8,1584877,3,10,3,
+6,10,4,8,1584879,1310721,2,3,26,2,10,3,6,10,4,8,
+1310721,2,3,26,2,1604491,12,1652197,16,5,1310721,2,3,26,2,26,
+1653909,14,1,1653909,14,1310721,2,5,26,1310721,2,2,1587809,12,10,3,
+6,10,4,8,1310721,2,5,26,2,1,40,3,36,1652321,16,1417729,
+1310721,2,5,26,2,26,2,11,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1652323,14,
+1,1652479,16,1442305,1310721,2,5,26,2,26,2,33,32,1,6,1,
+10,28,34,63,38,3,26,1652459,16,1310721,2,2,1652451,14,99,97,
+110,39,116,32,98,101,32,117,115,101,100,32,105,110,115,105,
+100,101,32,97,110,32,101,120,112,114,101,115,115,105,111,110,
+0,1652381,1586197,12,8,1310721,2,5,26,2,3,1647877,12,1653909,14,1310721,
+2,5,26,2,1,40,3,36,1652567,16,1417729,1310721,2,5,26,2,
+26,2,15,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1652569,14,1,1652669,16,1310721,2,
+2,1652629,14,105,115,32,97,32,116,121,112,101,44,32,110,111,
+116,32,97,32,118,97,108,117,101,0,1652583,1586197,12,8,1,1589149,
+12,8,1584987,1584975,2,10,3,6,10,4,8,1,1653909,14,1597071,12,
+8,1584987,1584975,2,10,3,6,10,4,8,1310721,2,5,26,2,1,
+40,3,36,1652781,16,1417729,1310721,2,5,26,2,26,2,9,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1652783,14,1,1652887,16,1425921,1310721,2,5,26,2,26,
+2,1589149,12,8,1584987,1584977,2,10,3,6,10,4,8,1584989,1425921,1310721,
+2,5,26,2,26,2,1,28,1,6,1,10,28,34,63,38,
+3,26,10,3,6,10,4,8,1,1653909,14,1310721,2,5,26,2,
+1,40,3,36,1652975,16,1417729,1310721,2,5,26,2,26,2,5,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1652977,14,1,1653091,16,1425921,1310721,2,5,26,2,
+26,2,1589149,12,8,1559041,1310721,2,5,26,2,26,2,1653053,16,1584987,
+1559041,1310721,2,5,26,2,26,2,10,3,6,10,4,8,1584875,3,
+10,3,6,10,4,8,1584877,5,10,3,6,10,4,8,1,1653909,
+14,1310721,2,5,26,2,1,40,3,36,1653179,16,1417729,1310721,2,5,
+26,2,26,2,7,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1653181,14,1,1653263,16,
+1425921,1310721,2,5,26,2,26,2,1589149,12,8,1559041,1310721,2,5,26,
+2,26,2,1653257,16,1584987,1559041,1310721,2,5,26,2,26,2,10,3,
+6,10,4,8,1,1653909,14,1310721,2,5,26,2,1,40,3,36,
+1653351,16,1417729,1310721,2,5,26,2,26,2,13,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1653353,14,1,1653375,16,1310721,2,5,26,2,1650345,12,1653909,14,1310721,
+2,5,26,2,1,40,1653423,16,1310721,2,5,26,1310721,2,2,1589617,
+12,10,3,6,10,4,8,1585015,2,1598497,12,1653481,16,1442305,1310721,2,
+5,26,2,26,2,257,32,1,6,1,10,28,34,63,38,1,
+10,28,1653483,14,1,1653805,16,1597071,12,8,1585087,1,10,3,6,10,
+4,8,3,1653683,16,1585087,2,17,40,3,36,1653591,16,1653583,14,116,
+111,111,32,109,97,110,121,32,116,121,112,101,32,97,114,103,
+117,109,101,110,116,115,0,1653535,1586063,12,8,1585071,1585087,2,26,1635249,
+12,10,3,6,10,4,8,1585087,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1584899,2,1598801,12,1,6,1,10,28,34,63,
+38,3,26,1653679,16,1653683,14,1653509,14,1635147,12,8,1584887,2,1598497,12,
+1,6,1,10,28,34,63,38,3,26,1653805,16,1653797,14,101,120,
+112,101,99,116,101,100,32,40,32,97,102,116,101,114,32,116,
+104,101,32,116,121,112,101,32,97,114,103,117,109,101,110,116,
+115,0,1653725,1586063,12,8,1584887,2,1598497,12,1653835,16,1310721,2,5,26,
+2,1649211,12,1653909,14,1310721,2,5,26,2,1589741,12,8,1559041,1310721,2,
+5,26,2,26,2,1653901,16,1584987,1559041,1310721,2,5,26,2,26,2,
+10,3,6,10,4,8,1,1653909,14,1,1310721,2,9,26,1310721,4,
+18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1653957,16,1966081,1310721,4,
+1579069,12,1310721,2,3,26,4,1310721,2,4,1584875,2,1,6,1,10,
+28,34,63,38,3,26,1654089,16,1654081,14,43,43,32,97,110,100,
+32,45,45,32,110,101,101,100,32,115,111,109,101,116,104,105,
+110,103,32,116,111,32,97,115,115,105,103,110,32,116,111,0,
+1654005,1586063,12,8,1584877,2,3,28,1,6,1,10,28,34,63,38,
+3,26,1654151,16,1584853,2,1,6,1,10,28,34,63,38,1,10,
+28,1654153,14,1,1654191,16,1584879,2,1604491,12,1,6,1,10,28,34,
+63,38,1,10,28,1654193,14,1,1654293,16,1584879,2,1654285,14,111,119,
+110,115,32,97,110,32,111,98,106,101,99,116,32,97,110,100,
+32,99,97,110,39,116,32,98,101,32,105,110,99,114,101,109,
+101,110,116,101,100,0,1654205,1586469,12,8,1584987,2,1629747,12,1654311,16,
+3,1654367,14,1584987,2,1,26,2,11,28,1,6,1,10,28,34,
+63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,1654377,
+16,3,1654429,14,1584987,2,1584975,2,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1654507,14,
+43,43,32,97,110,100,32,45,45,32,110,101,101,100,32,97,
+32,110,117,109,98,101,114,32,111,114,32,97,32,112,111,105,
+110,116,101,114,0,1654433,1584987,2,1634325,12,8,1584875,1,10,3,6,
+10,4,8,1584877,1,10,3,6,10,4,8,1584989,1,10,3,6,
+10,4,8,1,1589149,12,8,7,1589235,12,8,3,1589235,12,8,1310721,
+2,2,1654669,16,1,1589149,12,8,7,1589235,12,8,1310721,2,3,26,
+2,1589149,12,8,27,1589235,12,8,5,1589149,12,8,7,1589235,12,8,
+5,1589235,12,8,1654733,14,1310721,2,3,26,2,1589149,12,8,27,1589235,
+12,8,1,1589149,12,8,7,1589235,12,8,5,1589149,12,8,7,1589235,
+12,8,5,1589235,12,8,11,1589235,12,8,9,1589235,12,8,1,1654757,
+14,1,1310721,2,5,26,1310721,4,18,1310721,2,11,28,1310721,4,1310721,
+2,1835009,40,1654805,16,1966081,1310721,4,1579069,12,1310721,2,4,3,1,10,
+28,1310721,2,9,26,4,1597071,12,8,1310721,2,3,26,1599321,12,10,
+3,6,10,4,8,1647757,12,8,1310721,2,2,3,28,1,6,1,
+10,28,34,63,38,3,26,1655035,16,1655023,14,117,115,101,32,97,
+32,102,105,101,108,100,32,111,102,32,97,32,110,101,119,32,
+111,98,106,101,99,116,32,111,110,108,121,32,97,102,116,101,
+114,32,98,105,110,100,105,110,103,32,105,116,32,116,111,32,
+97,32,110,97,109,101,0,1654903,1586351,12,8,1655099,14,1310721,2,2,
+5,40,3,36,1655099,16,1310721,2,2,5,28,1604589,12,8,1310721,2,
+9,26,1310721,2,2,5,28,10,3,6,10,4,8,1310721,2,5,
+26,1584987,2,10,3,6,10,4,8,1310721,2,5,26,2,1,26,
+2,11,28,1,6,1,10,28,34,63,38,3,26,1655203,16,1310721,
+2,5,26,1310721,2,5,26,2,9,26,2,10,3,6,10,4,
+8,1310721,2,5,26,2,1,26,2,17,28,1,6,1,10,28,
+34,63,38,1,10,28,1655553,16,1585091,2,1,6,1,10,28,34,
+63,38,3,26,1655327,16,1584991,2,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1655329,14,1,
+1655497,16,1585093,12,8,93,1573101,12,8,1310721,2,3,26,2,1573341,12,
+8,1655391,14,58,32,116,104,97,116,39,115,32,97,32,0,1655367,
+1573341,12,8,1584987,2,1632681,12,8,1655483,14,44,32,110,111,116,32,
+97,32,115,116,114,117,99,116,32,111,114,32,97,32,112,111,
+105,110,116,101,114,32,116,111,32,111,110,101,0,1655413,1573341,12,
+8,1585237,12,8,1584987,1584975,2,10,3,6,10,4,8,1584875,3,10,
+3,6,10,4,8,1584877,9,10,3,6,10,4,8,1,1656109,14,
+1310721,2,7,26,1310721,2,5,26,2,1310721,2,3,26,2,1640559,12,
+10,3,6,10,4,8,1310721,2,7,26,2,1,40,1655841,16,1585091,
+2,1,6,1,10,28,34,63,38,3,26,1655693,16,1584991,2,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1655695,14,1,1655785,16,1585093,12,8,1310721,2,5,26,
+2,1632681,12,8,1655755,14,32,104,97,115,32,110,111,32,102,105,
+101,108,100,32,0,1655725,1573341,12,8,1310721,2,3,26,2,1573341,12,
+8,1585237,12,8,1584987,1584975,2,10,3,6,10,4,8,1584875,3,10,
+3,6,10,4,8,1584877,9,10,3,6,10,4,8,1,1656109,14,
+1310721,2,5,26,2,9,26,2,1310721,2,7,26,2,7,30,5,
+26,26,2,1655935,16,1310721,2,5,26,2,9,26,2,1310721,2,7,
+26,2,7,30,5,26,26,2,1589149,12,8,27,1589235,12,8,1584987,
+1310721,2,5,26,2,9,26,2,1310721,2,7,26,2,7,30,3,
+26,26,2,10,3,6,10,4,8,1584875,3,10,3,6,10,4,
+8,1584989,1,10,3,6,10,4,8,1310721,2,9,26,2,1,40,
+3,36,1656085,16,1584877,7,10,3,6,10,4,8,1584879,1310721,2,9,
+26,2,10,3,6,10,4,8,1656101,14,1584877,9,10,3,6,10,
+4,8,1,1656109,14,1,1310721,2,11,26,1310721,4,18,1310721,2,29,
+28,1310721,4,1310721,2,1835009,40,1656157,16,1966081,1310721,4,1579069,12,1651083,12,
+1310721,2,4,3,1658085,16,1582577,2,5,28,1,6,1,10,28,34,
+63,38,3,26,1656261,16,1582579,2,1584935,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1656263,14,1,1656347,16,1597071,12,8,1310721,2,7,26,1635249,12,10,3,
+6,10,4,8,1647757,12,8,1584987,1310721,2,7,26,2,10,3,6,
+10,4,8,1584877,1,10,3,6,10,4,8,1656167,14,1582577,2,9,
+28,1,6,1,10,28,34,63,38,1,10,28,1656391,16,1310721,2,
+2,1658097,14,1582579,2,1584895,2,28,1,6,1,10,28,34,63,38,
+3,26,1657305,16,1597071,12,8,1647757,12,8,1310721,2,3,26,3,1,
+10,28,10,3,6,10,4,8,1310721,2,2,3,28,1,6,1,
+10,28,34,63,38,3,26,1656617,16,1656605,14,105,110,100,101,120,
+32,97,32,110,101,119,32,111,98,106,101,99,116,32,111,110,
+108,121,32,97,102,116,101,114,32,98,105,110,100,105,110,103,
+32,105,116,32,116,111,32,97,32,110,97,109,101,0,1656503,1586351,
+12,8,1656681,14,1310721,2,2,5,40,3,36,1656681,16,1310721,2,2,
+5,28,1604589,12,8,1310721,2,3,26,1310721,2,2,5,28,10,3,
+6,10,4,8,1584987,2,1630143,12,1656699,16,3,1656751,14,1584987,2,1584975,
+2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1656835,14,111,110,108,121,32,112,111,
+105,110,116,101,114,115,32,97,110,100,32,97,114,114,97,121,
+115,32,99,97,110,32,98,101,32,105,110,100,101,120,101,100,
+0,1656755,1584987,2,1634325,12,8,1310721,2,9,26,1584987,2,1630433,12,10,
+3,6,10,4,8,1310721,2,1662195,12,10,3,6,10,4,8,1647757,
+12,8,1310721,2,2,1605077,12,8,1584987,2,1629747,12,1656931,16,3,1656983,
+14,1584987,2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1657043,14,97,110,32,
+105,110,100,101,120,32,104,97,115,32,116,111,32,98,101,32,
+97,32,110,117,109,98,101,114,0,1656987,1584987,2,1634325,12,8,1584897,
+2,1599031,12,8,1310721,2,9,26,2,1628577,12,3,28,1,6,1,
+10,28,34,63,38,1,10,28,1657137,16,1310721,2,9,26,2,1628577,
+12,1589149,12,8,31,1589235,12,8,27,1589235,12,8,1584875,3,10,3,
+6,10,4,8,1584987,1310721,2,9,26,2,10,3,6,10,4,8,
+1584989,1,10,3,6,10,4,8,1310721,2,3,26,2,1,40,3,
+36,1657267,16,1584877,7,10,3,6,10,4,8,1584879,1310721,2,3,26,
+2,10,3,6,10,4,8,1657283,14,1584877,9,10,3,6,10,4,
+8,1310721,2,1,10,3,6,10,4,8,1656167,14,1582579,2,1584925,2,
+28,1,6,1,10,28,34,63,38,3,26,1657345,16,3,1657397,14,
+1582579,2,1584905,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1657431,16,1310721,2,1310721,2,
+2,1654771,12,10,3,6,10,4,8,1656167,14,1582579,2,1584887,2,28,
+1,6,1,10,28,34,63,38,3,26,1657929,16,1647757,12,8,1310721,
+2,2,1605077,12,8,1310721,2,11,26,1,10,3,6,10,4,8,
+1584987,2,1,26,2,15,28,1,6,1,10,28,34,63,38,3,
+26,1657571,16,1310721,2,11,26,1584987,2,10,3,6,10,4,8,1657675,
+14,1584987,2,1584975,2,28,1,6,1,10,28,34,63,38,3,26,
+1657663,14,111,110,108,121,32,102,117,110,99,116,105,111,110,115,
+32,99,97,110,32,98,101,32,99,97,108,108,101,100,0,1657605,
+1584987,2,1634325,12,8,1310721,2,13,26,1,17,1574549,12,8,1310721,2,
+5,26,1,1310721,2,11,26,2,1310721,2,13,26,1648325,12,10,3,
+6,10,4,8,1310721,2,5,26,2,1589149,12,8,7,1589235,12,8,
+13,1589235,12,8,11,1589235,12,8,9,1589235,12,8,1584875,1,10,3,
+6,10,4,8,1584877,1,10,3,6,10,4,8,1310721,2,1,10,
+3,6,10,4,8,1584989,1,10,3,6,10,4,8,1584987,1584975,2,
+10,3,6,10,4,8,1310721,2,11,26,2,1657925,16,1584987,1310721,2,
+11,26,2,9,26,2,1310721,2,13,26,1628749,12,10,3,6,10,
+4,8,1656167,14,1582579,2,1584907,2,28,1,6,1,10,28,34,63,
+38,3,26,1657997,16,1597071,12,8,1310721,2,3,3,1653923,12,10,3,
+6,10,4,8,1656167,14,1582579,2,1584909,2,28,1,6,1,10,28,
+34,63,38,3,26,1658071,16,1597071,12,8,1310721,2,3,3,1,10,
+28,1653923,12,10,3,6,10,4,8,1656167,14,1310721,2,2,1658097,14,
+1656167,14,1310721,2,2,1658097,14,1,1310721,2,29,26,1310721,4,18,1310721,
+2,7,28,1310721,4,1310721,2,1835009,40,1658145,16,1966081,1310721,4,1579069,12,
+1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,1658357,16,
+1582579,2,1584945,2,28,1,6,1,10,28,34,63,38,3,26,1658217,
+16,3,1658269,14,1582579,2,1584941,2,28,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1658279,16,
+3,1658331,14,1582579,2,1584943,2,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1,6,1,
+10,28,34,63,38,1,10,28,1658359,14,1,1658579,16,1310721,2,5,
+26,3,10,3,6,10,4,8,1582579,2,1584945,2,28,1,6,1,
+10,28,34,63,38,3,26,1658441,16,1310721,2,5,26,5,10,3,
+6,10,4,8,1582579,2,1584943,2,28,1,6,1,10,28,34,63,
+38,3,26,1658497,16,1310721,2,5,26,7,10,3,6,10,4,8,
+1597071,12,8,1584911,2,1599031,12,8,1310721,2,1658111,12,10,3,6,10,
+4,8,1647757,12,8,1584877,1,10,3,6,10,4,8,1310721,2,2,
+1310721,2,5,26,2,1615689,12,1659775,14,1582577,2,9,28,1,6,1,
+10,28,34,63,38,3,26,1659765,16,1582579,2,1584911,2,28,1,6,
+1,10,28,34,63,38,3,26,1658945,16,1597071,12,8,1310721,2,1658111,
+12,10,3,6,10,4,8,1647757,12,8,1310721,2,2,1605077,12,8,
+1584987,2,1,26,2,11,28,1,6,1,10,28,34,63,38,3,
+26,1658733,16,3,1658785,14,1584987,2,1584975,2,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1658857,14,111,110,108,121,32,112,111,105,110,116,101,114,115,32,
+99,97,110,32,98,101,32,100,101,114,101,102,101,114,101,110,
+99,101,100,0,1658789,1584987,2,1634325,12,8,1584987,1584987,2,1630433,12,10,
+3,6,10,4,8,1584875,3,10,3,6,10,4,8,1584877,9,10,
+3,6,10,4,8,1584989,1,10,3,6,10,4,8,1,1659775,14,
+1582579,2,1584913,2,28,1,6,1,10,28,34,63,38,3,26,1659275,
+16,1597071,12,8,1310721,2,1658111,12,10,3,6,10,4,8,1584875,2,
+1,6,1,10,28,34,63,38,3,26,1659087,16,1584987,2,1629979,12,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1659089,14,1,1659165,16,1659157,14,38,32,110,101,
+101,100,115,32,115,111,109,101,116,104,105,110,103,32,97,100,
+100,114,101,115,115,97,98,108,101,0,1659097,1586063,12,8,1310721,2,
+2,5,40,3,36,1659199,16,1310721,2,2,5,28,1604589,12,8,1584875,
+1,10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,1584989,
+1,10,3,6,10,4,8,1584987,1584987,2,1624435,12,10,3,6,10,
+4,8,1,1659775,14,1582579,2,1584907,2,28,1,6,1,10,28,34,
+63,38,3,26,1659333,16,1597071,12,8,1658111,12,8,1,3,1653923,12,
+1659775,14,1582579,2,1584909,2,28,1,6,1,10,28,34,63,38,3,
+26,1659397,16,1597071,12,8,1658111,12,8,1,3,1,10,28,1653923,12,
+1659775,14,1310721,2,3,26,1582579,2,1601755,12,10,3,6,10,4,8,
+1310721,2,3,26,2,1,40,3,36,1659765,16,1597071,12,8,1310721,2,
+1658111,12,10,3,6,10,4,8,1647757,12,8,1310721,2,2,1605077,12,
+8,1547329,1310721,2,3,26,2,26,2,1547393,1310721,2,3,26,2,26,
+2,1600817,12,8,1310721,2,3,26,2,3,10,40,3,36,1659575,16,
+1584987,1584981,2,10,3,6,10,4,8,1659711,14,1584987,2,1584975,2,28,
+1,6,1,10,28,34,63,38,1,10,28,1659711,16,1584987,2,1629747,
+12,1659681,14,116,104,105,115,32,111,112,101,114,97,116,111,114,
+32,110,101,101,100,115,32,97,32,110,117,109,98,101,114,0,
+1659623,1584987,2,1634325,12,8,1584987,1584977,2,10,3,6,10,4,8,1584875,
+1,10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,1584989,
+1,10,3,6,10,4,8,1,1659775,14,1656123,12,1659775,14,1,1310721,
+2,7,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,2,1835009,40,
+1659823,16,1966081,1310721,4,1579069,12,1310721,2,4,1658111,12,1310721,2,3,26,
+4,1582577,2,9,28,1,6,1,10,28,34,63,38,3,26,1660769,
+16,1310721,2,5,26,1582579,2,1601559,12,10,3,6,10,4,8,1310721,
+2,5,26,2,1,40,1659935,16,1310721,2,3,26,2,1660785,14,1310721,
+2,7,26,1546881,1310721,2,5,26,2,26,2,10,3,6,10,4,
+8,1310721,2,7,26,2,1310721,2,2,40,1660007,16,1310721,2,3,26,
+2,1660785,14,1597071,12,8,1647757,12,8,1310721,2,3,26,2,1605077,12,
+8,1310721,2,13,26,1584987,2,10,3,6,10,4,8,1547137,1310721,2,
+5,26,2,26,2,3,1,10,28,28,1,6,1,10,28,34,
+63,38,3,26,1660307,16,1310721,2,9,26,1589535,12,10,3,6,10,
+4,8,17,1589235,12,8,1310721,2,3,26,1310721,2,7,26,2,3,
+26,1659789,12,10,3,6,10,4,8,1647757,12,8,1310721,2,3,26,
+2,1605077,12,8,1547329,3,26,2,1547393,3,26,2,1600817,12,8,1310721,
+2,11,26,1589535,12,10,3,6,10,4,8,15,1589235,12,8,1310721,
+2,9,26,2,1584837,2,1589317,12,8,1,1589149,12,8,1310721,2,11,
+26,2,1584837,2,1589317,12,8,1660653,14,1547137,1310721,2,5,26,2,26,
+2,5,1,10,28,28,1,6,1,10,28,34,63,38,3,26,
+1660555,16,1310721,2,9,26,1589535,12,10,3,6,10,4,8,17,1589235,
+12,8,3,1589149,12,8,1310721,2,11,26,1589535,12,10,3,6,10,
+4,8,15,1589235,12,8,1310721,2,9,26,2,1584837,2,1589317,12,8,
+1310721,2,3,26,1310721,2,7,26,2,3,26,1659789,12,10,3,6,
+10,4,8,1647757,12,8,1310721,2,3,26,2,1605077,12,8,1547329,3,
+26,2,1547393,3,26,2,1600817,12,8,1310721,2,11,26,2,1584837,2,
+1589317,12,8,1660653,14,1310721,2,3,26,1310721,2,7,26,2,3,26,
+1659789,12,10,3,6,10,4,8,1647757,12,8,1310721,2,3,26,2,
+1605077,12,8,1547009,1310721,2,5,26,2,26,2,1547137,1310721,2,5,26,
+2,26,2,1600817,12,8,1584987,1310721,2,5,26,2,1310721,2,13,26,
+2,1584987,2,1642719,12,10,3,6,10,4,8,1584875,1,10,3,6,
+10,4,8,1584877,1,10,3,6,10,4,8,1310721,2,3,26,1,
+10,3,6,10,4,8,1584989,1,10,3,6,10,4,8,1659843,14,
+1310721,2,3,26,2,1660785,14,1,1310721,2,15,26,1310721,4,18,1310721,
+2,1,28,1310721,4,1310721,2,1835009,40,1660833,16,1966081,1310721,4,1579069,12,
+11,1589235,12,8,3,1589149,12,8,7,1589235,12,8,11,1589235,12,8,
+5,1589235,12,8,1,1660881,14,1,1310721,2,1,26,1310721,4,18,1310721,
+2,23,28,1310721,4,1310721,2,1835009,40,1660929,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1584857,2,1310721,2,13,26,4,1584845,2,1310721,2,15,26,
+4,1647757,12,8,1310721,2,2,1605077,12,8,1597071,12,8,1310721,2,3,
+26,1589535,12,10,3,6,10,4,8,17,1589235,12,8,1310721,2,7,
+26,1606761,12,10,3,6,10,4,8,1310721,2,17,26,1662195,12,10,
+3,6,10,4,8,1647757,12,8,1310721,2,21,26,1584987,2,10,3,
+6,10,4,8,1310721,2,17,26,2,3,28,1,6,1,10,28,
+34,63,38,1,10,28,1661153,16,1310721,2,17,26,2,1605077,12,8,
+1310721,2,11,26,1584857,2,10,3,6,10,4,8,1310721,2,9,26,
+1606761,12,10,3,6,10,4,8,1310721,2,5,26,1589535,12,10,3,
+6,10,4,8,15,1589235,12,8,1584915,2,1599031,12,8,1310721,2,3,
+26,2,1584837,2,1589317,12,8,1310721,2,7,26,2,1607393,12,8,1584857,
+1310721,2,13,26,2,10,3,6,10,4,8,1310721,2,19,26,1662195,
+12,10,3,6,10,4,8,1647757,12,8,1310721,2,19,26,2,3,
+28,1,6,1,10,28,34,63,38,1,10,28,1661389,16,1310721,2,
+19,26,2,1605077,12,8,1310721,2,9,26,2,1310721,2,11,26,2,
+1310721,2,5,26,2,1584857,2,1310721,2,15,26,2,1661527,14,101,110,
+100,115,32,116,104,101,32,116,119,111,32,115,105,100,101,115,
+32,111,102,32,63,58,32,105,110,32,100,105,102,102,101,114,
+101,110,116,32,115,116,97,116,101,115,0,1661437,1615115,12,8,1310721,
+2,7,26,2,1607311,12,8,1310721,2,21,26,2,1584987,2,1630621,12,
+1,6,1,10,28,34,63,38,3,26,1661657,16,1584987,2,1310721,2,
+21,26,2,1630621,12,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1661659,14,1,1661729,16,1661707,
+14,116,104,101,32,116,119,111,32,115,105,100,101,115,32,111,
+102,32,63,58,0,1661667,1310721,2,21,26,2,1584987,2,1633925,12,8,
+1310721,2,21,26,2,1584975,2,28,1,6,1,10,28,34,63,38,
+1,10,28,1661795,16,1584987,1310721,2,21,26,2,10,3,6,10,4,
+8,1584875,1,10,3,6,10,4,8,1584877,1,10,3,6,10,4,
+8,1584989,1,10,3,6,10,4,8,1310721,2,17,26,2,3,28,
+1,6,1,10,28,34,63,38,3,26,1661941,16,1310721,2,19,26,
+2,3,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1661943,14,1,1661953,16,3,1662181,14,
+1310721,2,17,26,2,3,28,1,6,1,10,28,34,63,38,3,
+26,1661997,16,3,1662053,14,1310721,2,19,26,2,3,28,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1662173,16,1662165,14,98,111,116,104,32,115,105,100,101,115,
+32,111,102,32,63,58,32,104,97,118,101,32,116,111,32,98,
+101,32,110,101,119,32,111,98,106,101,99,116,115,44,32,111,
+114,32,110,101,105,116,104,101,114,0,1662061,1586351,12,8,1,1662181,
+14,1,1310721,2,23,26,1310721,4,18,1310721,2,13,28,1310721,4,1310721,
+2,1835009,40,1662229,16,1966081,1310721,4,1579069,12,3,1659789,12,1310721,2,4,
+1582577,2,9,28,1,6,1,10,28,34,63,38,1,10,28,1662285,
+16,1310721,2,2,1663727,14,1582579,2,1584947,2,28,1,6,1,10,28,
+34,63,38,3,26,1662333,16,1310721,2,2,1660895,12,1663727,14,1582579,2,
+1584903,2,28,1,6,1,10,28,34,63,38,3,26,1662925,16,1584875,
+2,1,6,1,10,28,34,63,38,3,26,1662459,16,1662451,14,116,
+104,105,115,32,99,97,110,39,116,32,98,101,32,97,115,115,
+105,103,110,101,100,32,116,111,0,1662399,1586063,12,8,1310721,2,3,
+26,1584877,2,10,3,6,10,4,8,1310721,2,5,26,1584879,2,10,
+3,6,10,4,8,1310721,2,11,26,1584987,2,10,3,6,10,4,
+8,1310721,2,11,26,2,1629979,12,1662683,16,1662675,14,97,32,119,104,
+111,108,101,32,115,116,114,117,99,116,32,111,114,32,97,114,
+114,97,121,32,99,97,110,39,116,32,98,101,32,97,115,115,
+105,103,110,101,100,59,32,97,115,115,105,103,110,32,105,116,
+115,32,102,105,101,108,100,115,0,1662553,1585679,12,8,1597071,12,8,
+1310721,2,9,26,1662195,12,10,3,6,10,4,8,1647757,12,8,1310721,
+2,11,26,2,1584987,2,1630621,12,1,6,1,10,28,34,63,38,
+3,26,1662809,16,1662787,14,97,115,115,105,103,110,109,101,110,116,
+0,1662765,1310721,2,11,26,2,1584987,2,1633925,12,8,1660799,12,8,1584875,
+1,10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,1584987,
+1310721,2,11,26,2,10,3,6,10,4,8,1584989,1,10,3,6,
+10,4,8,1310721,2,3,26,2,1310721,2,5,26,2,1310721,2,9,
+26,2,1618391,12,1663727,14,1310721,2,7,26,1582579,2,1601951,12,10,3,
+6,10,4,8,1310721,2,7,26,2,1,40,3,36,1663715,16,1584875,
+2,1,6,1,10,28,34,63,38,3,26,1663067,16,1663059,14,116,
+104,105,115,32,99,97,110,39,116,32,98,101,32,97,115,115,
+105,103,110,101,100,32,116,111,0,1663007,1586063,12,8,1584877,2,3,
+28,1,6,1,10,28,34,63,38,3,26,1663129,16,1584853,2,1,
+6,1,10,28,34,63,38,1,10,28,1663131,14,1,1663169,16,1584879,
+2,1604491,12,1,6,1,10,28,34,63,38,1,10,28,1663171,14,
+1,1663291,16,1584879,2,1663283,14,111,119,110,115,32,97,110,32,111,
+98,106,101,99,116,59,32,99,111,109,112,111,117,110,100,32,
+97,115,115,105,103,110,109,101,110,116,32,119,111,117,108,100,
+32,108,111,115,101,32,105,116,0,1663183,1586469,12,8,1310721,2,11,
+26,1584987,2,10,3,6,10,4,8,1597071,12,8,1,1589149,12,8,
+7,1589235,12,8,3,1589235,12,8,1584875,1,10,3,6,10,4,8,
+1310721,2,9,26,1662195,12,10,3,6,10,4,8,1647757,12,8,1310721,
+2,9,26,2,1605077,12,8,1547009,1547585,1310721,2,7,26,2,26,2,
+26,2,1547137,1547585,1310721,2,7,26,2,26,2,26,2,1600817,12,8,
+1310721,2,3,26,1547585,1310721,2,7,26,2,26,2,1310721,2,11,26,
+2,1584987,2,1642719,12,10,3,6,10,4,8,1310721,2,11,26,2,
+1310721,2,3,26,2,1630621,12,1,6,1,10,28,34,63,38,3,
+26,1663631,16,1663603,14,99,111,109,112,111,117,110,100,32,97,115,
+115,105,103,110,109,101,110,116,0,1663563,1310721,2,11,26,2,1310721,
+2,3,26,2,1633925,12,8,1660799,12,8,1584875,1,10,3,6,10,
+4,8,1584877,1,10,3,6,10,4,8,1584987,1310721,2,11,26,2,
+10,3,6,10,4,8,1584989,1,10,3,6,10,4,8,1,1663727,
+14,1310721,2,2,1663727,14,1,1310721,2,13,26,1310721,4,18,1310721,2,
+3,28,1310721,4,1310721,2,1835009,40,1663775,16,1966081,1310721,4,1579069,12,1582577,
+2,9,28,1,6,1,10,28,34,63,38,3,26,1663939,16,1582579,
+2,1584901,2,28,1,6,1,10,28,34,63,38,3,26,1663847,16,
+3,1663899,14,1582579,2,1584891,2,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1663909,16,3,
+1663935,14,1637143,12,1,6,1,10,28,34,63,38,1,10,28,1664221,
+14,1582577,2,5,28,1,6,1,10,28,34,63,38,1,10,28,
+1663979,16,3,1664017,14,1582579,2,1603687,12,1,40,3,36,1,6,1,
+10,28,34,63,38,1,10,28,1664027,16,1,1664221,14,1637143,12,1664041,
+16,3,1664221,14,1310721,2,1582579,2,1587809,12,10,3,6,10,4,8,
+1310721,2,2,1,40,3,36,1664145,16,1417729,1310721,2,2,26,2,11,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1664147,14,1,1664213,16,1442305,1310721,2,2,26,
+2,33,32,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1664215,14,1,1664221,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1664269,
+16,1966081,1310721,4,1579069,12,1584845,2,1310721,2,4,1,1310721,2,3,26,
+4,1,1310721,2,5,26,4,1584977,2,1310721,2,7,26,4,1597071,12,
+8,1584849,1,6,2,1,6,3,26,5,6,4,10,8,8,1584859,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1584893,2,1598497,
+12,1,6,1,10,28,34,63,38,3,26,1664751,16,1582577,2,1,
+28,1,6,1,10,28,34,63,38,3,26,1664475,16,1664467,14,109,
+105,115,115,105,110,103,32,125,0,1664447,1586063,12,8,1663741,12,1664493,
+16,1666771,12,8,1664379,14,1310721,2,3,26,1662195,12,10,3,6,10,
+4,8,1647757,12,8,1584901,2,1598801,12,1664585,16,9,1589235,12,8,1310721,
+2,3,26,2,1623627,12,8,1310721,2,3,26,1,10,3,6,10,
+4,8,1664379,14,1584893,2,1598497,12,1,6,1,10,28,34,63,38,
+3,26,1664701,16,1664693,14,101,120,112,101,99,116,101,100,32,59,
+32,111,114,32,125,32,97,102,116,101,114,32,97,110,32,101,
+120,112,114,101,115,115,105,111,110,0,1664621,1586063,12,8,1310721,2,
+5,26,3,10,3,6,10,4,8,1310721,2,7,26,1584987,2,10,
+3,6,10,4,8,1664379,14,1597071,12,8,1310721,2,5,26,2,1664809,
+16,1310721,2,3,26,1310721,2,3,26,2,1622911,12,10,3,6,10,
+4,8,1664817,14,1,1589149,12,8,1310721,2,2,1606489,12,8,1584849,1,
+6,2,1,6,-1,26,5,6,4,10,8,8,1584859,1,6,2,
+1,6,-1,26,5,6,4,10,8,8,1584875,1,10,3,6,10,
+4,8,1584877,1,10,3,6,10,4,8,1584987,1310721,2,7,26,2,
+10,3,6,10,4,8,1584989,1,10,3,6,10,4,8,1310721,2,
+3,26,2,1664973,14,1,1310721,2,9,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1665021,16,1966081,1310721,4,1579069,12,1582577,2,
+3,28,1,6,1,10,28,34,63,38,3,26,1665089,16,1310721,2,
+1582579,2,10,3,6,10,4,8,1597071,12,8,1310721,2,2,1665789,14,
+1584919,2,1598801,12,1665113,16,1,1664987,12,28,1665789,14,1582577,2,9,28,
+1,6,1,10,28,34,63,38,3,26,1665205,16,1582579,2,1547265,5,
+26,2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1665207,14,1,1665229,16,1597071,12,8,
+1664987,12,-1,36,1665789,14,1584887,2,1598801,12,1665281,16,1310721,2,1665803,12,
+10,3,6,10,4,8,1584889,2,1599031,12,8,1310721,2,2,1665789,14,
+1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,1665729,16,
+1310721,2,3,26,1582579,2,1587809,12,10,3,6,10,4,8,1310721,2,
+3,26,2,1,40,3,36,1665697,16,1417729,1310721,2,3,26,2,26,
+2,9,28,1,6,1,10,28,34,63,38,3,26,1665413,16,3,
+1665475,14,1417729,1310721,2,3,26,2,26,2,7,28,1,6,1,10,
+28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,
+28,1665485,16,3,1665599,14,1417729,1310721,2,3,26,2,26,2,3,28,
+1,6,1,10,28,34,63,38,3,26,1665575,16,1442305,1310721,2,3,
+26,2,26,2,3,32,1,6,1,10,28,34,63,38,1,10,
+28,1665577,14,1,1,6,1,10,28,34,63,38,1,10,28,1665609,
+16,3,1665671,14,1417729,1310721,2,3,26,2,26,2,5,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1,6,1,10,28,34,63,38,1,10,28,1665699,14,
+1,1665729,16,1597071,12,8,1425921,1310721,2,3,26,2,26,2,1665789,14,
+1665773,14,101,120,112,101,99,116,101,100,32,97,32,99,111,110,
+115,116,97,110,116,0,1665733,1586063,12,8,1,1665789,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1665837,
+16,1966081,1310721,4,1579069,12,1664987,12,1310721,2,4,1582577,2,9,28,1,
+6,1,10,28,34,63,38,3,26,1666491,16,1310721,2,3,26,1582579,
+2,10,3,6,10,4,8,1310721,2,3,26,2,1546753,7,26,2,
+28,1,6,1,10,28,34,63,38,3,26,1665985,16,1597071,12,8,
+1310721,2,1310721,2,2,1664987,12,26,10,3,6,10,4,8,1666487,14,
+1310721,2,3,26,2,1546753,9,26,2,28,1,6,1,10,28,34,
+63,38,3,26,1666067,16,1597071,12,8,1310721,2,1310721,2,2,1664987,12,
+28,10,3,6,10,4,8,1666487,14,1310721,2,3,26,2,1546753,1,
+26,2,28,1,6,1,10,28,34,63,38,3,26,1666149,16,1597071,
+12,8,1310721,2,1310721,2,2,1664987,12,30,10,3,6,10,4,8,
+1666487,14,1310721,2,3,26,2,1546753,31,26,2,28,1,6,1,10,
+28,34,63,38,3,26,1666231,16,1597071,12,8,1310721,2,1310721,2,2,
+1664987,12,34,10,3,6,10,4,8,1666487,14,1310721,2,3,26,2,
+1546753,27,26,2,28,1,6,1,10,28,34,63,38,3,26,1666313,
+16,1597071,12,8,1310721,2,1310721,2,2,1664987,12,32,10,3,6,10,
+4,8,1666487,14,1310721,2,3,26,2,1546753,11,26,2,28,1,6,
+1,10,28,34,63,38,3,26,1666395,16,1597071,12,8,1310721,2,1310721,
+2,2,1664987,12,48,10,3,6,10,4,8,1666487,14,1310721,2,3,
+26,2,1546753,13,26,2,28,1,6,1,10,28,34,63,38,3,
+26,1666477,16,1597071,12,8,1310721,2,1310721,2,2,1664987,12,38,10,3,
+6,10,4,8,1666487,14,1310721,2,2,1666503,14,1665847,14,1310721,2,2,
+1666503,14,1,1310721,2,5,26,1310721,4,18,1310721,2,1,28,1310721,4,
+1310721,2,1835009,40,1666551,16,1966081,1310721,4,1579069,12,1582577,2,1,28,1,
+6,1,10,28,34,63,38,1,10,28,1666639,16,1584901,2,1598497,12,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1666641,14,1,1666699,16,1584893,2,1598497,12,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1666701,14,1,1666715,16,1597071,12,8,1666551,14,1584901,2,1598497,
+12,1666733,16,1597071,12,8,1585091,1,10,3,6,10,4,8,1,1666757,
+14,1,1310721,2,1,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1666805,16,1966081,1310721,4,1579069,12,1585091,2,1666821,16,1666517,12,
+1667293,14,1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,
+1666891,16,1582579,2,1603687,12,1,40,1,6,1,10,28,34,63,38,
+1,10,28,1666893,14,1,1667075,16,1310721,2,1582579,2,1587809,12,10,3,
+6,10,4,8,1310721,2,2,1,40,3,36,1667001,16,1417729,1310721,2,
+2,26,2,11,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1667003,14,1,1667049,16,1442305,
+1310721,2,2,26,2,17,32,1,6,1,10,28,34,63,38,1,
+10,28,1667051,14,1,1667075,16,1310721,2,2,1,1647877,12,8,1,1667293,
+14,1637143,12,1667097,16,3,1667723,12,8,1,1667293,14,1582577,2,9,28,
+1,6,1,10,28,34,63,38,3,26,1667221,16,1582579,2,1584901,2,
+28,1,6,1,10,28,34,63,38,3,26,1667175,16,1597071,12,8,
+1,1667293,14,1582579,2,1584891,2,28,1,6,1,10,28,34,63,38,
+3,26,1667221,16,1667307,12,8,1,1667293,14,1310721,2,3,26,1662195,12,
+10,3,6,10,4,8,1647757,12,8,9,1589235,12,8,1584901,2,1599031,
+12,8,1310721,2,3,26,2,1623627,12,8,1,1667293,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1667341,
+16,1966081,1310721,4,1579069,12,1584845,2,1310721,2,4,1584891,2,1599031,12,8,
+1584849,1,6,2,1,6,3,26,5,6,4,10,8,8,1584893,2,
+1598497,12,1,6,1,10,28,34,63,38,3,26,1667495,16,1582577,2,
+1,28,1,6,1,10,28,34,63,38,3,26,1667485,16,1667477,14,
+109,105,115,115,105,110,103,32,125,0,1667457,1586063,12,8,1666771,12,
+8,1667389,14,1310721,2,2,1606489,12,8,1597071,12,8,1584849,1,6,2,
+1,6,-1,26,5,6,4,10,8,8,1,1667549,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1667597,
+16,1966081,1310721,4,1579069,12,1584845,2,1310721,2,4,1584891,2,1598497,12,1667627,
+16,1667307,12,1667709,14,1584849,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1666771,12,8,1310721,2,2,1606489,12,8,1584849,1,6,2,
+1,6,-1,26,5,6,4,10,8,8,1,1667709,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,2,1835009,40,1667757,
+16,1966081,1310721,4,1579069,12,1310721,2,4,1,1310721,2,11,26,4,1,
+1310721,2,13,26,4,1310721,2,2,1667953,16,1637945,12,8,1310721,2,11,
+26,1585011,2,10,3,6,10,4,8,1310721,2,13,26,1585013,2,10,
+3,6,10,4,8,1310721,2,11,26,2,1584983,2,28,1,6,1,
+10,28,34,63,38,3,26,1667953,16,1667945,14,97,32,118,97,114,
+105,97,98,108,101,32,99,97,110,39,116,32,98,101,32,118,
+111,105,100,0,1667895,1585679,12,8,3,1668961,16,1310721,2,3,26,1599321,
+12,10,3,6,10,4,8,1310721,2,5,26,1310721,2,3,26,2,
+1603891,12,10,3,6,10,4,8,1558017,1310721,2,5,26,2,26,1310721,
+2,13,26,2,10,3,6,10,4,8,1584895,2,1598801,12,1668279,16,
+1310721,2,9,26,1665803,12,10,3,6,10,4,8,1584897,2,1599031,12,
+8,1310721,2,11,26,2,1,6,1,10,28,34,63,38,3,26,
+1668157,16,1310721,2,11,26,1584975,2,10,3,6,10,4,8,1473025,1310721,
+2,5,26,2,26,3,10,3,6,10,4,8,1556993,1310721,2,5,
+26,2,26,1310721,2,11,26,2,1310721,2,9,26,2,1624809,12,10,
+3,6,10,4,8,1584851,1584851,2,1556993,1310721,2,5,26,2,26,2,
+1628577,12,26,10,3,6,10,4,8,1668519,14,1310721,2,11,26,2,
+1668333,16,1310721,2,11,26,2,1629979,12,1,6,1,10,28,34,63,
+38,1,10,28,1668335,14,1,1668441,16,1473025,1310721,2,5,26,2,26,
+3,10,3,6,10,4,8,1556993,1310721,2,5,26,2,26,1310721,2,
+11,26,2,10,3,6,10,4,8,1584851,1584851,2,1310721,2,11,26,
+2,1628577,12,26,10,3,6,10,4,8,1668519,14,1584851,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1310721,2,11,26,2,1668519,
+16,1556993,1310721,2,5,26,2,26,1310721,2,11,26,2,10,3,6,
+10,4,8,1584903,2,1598801,12,1668921,16,1473025,1310721,2,5,26,2,26,
+2,1668661,16,1668653,14,97,110,32,97,114,114,97,121,32,111,114,
+32,97,32,115,116,114,117,99,116,32,99,97,110,39,116,32,
+98,101,32,105,110,105,116,105,97,108,105,122,101,100,32,119,
+105,116,104,32,61,0,1668555,1585679,12,8,1310721,2,7,26,1662195,12,
+10,3,6,10,4,8,1647757,12,8,1467905,1310721,2,5,26,2,26,
+2,1590069,12,8,5,1589235,12,8,1310721,2,11,26,2,1668831,16,1310721,
+2,11,26,2,1584987,2,1630621,12,1,6,1,10,28,34,63,38,
+3,26,1668827,16,1668805,14,105,110,105,116,105,97,108,105,122,101,
+114,0,1668781,1310721,2,11,26,2,1584987,2,1633925,12,8,1668893,14,1584987,
+2,1629747,12,1,6,1,10,28,34,63,38,3,26,1668893,16,1556993,
+1310721,2,5,26,2,26,1584987,2,10,3,6,10,4,8,3,1310721,
+2,5,26,2,1310721,2,7,26,2,1618391,12,8,1584899,2,1598801,12,
+1,6,1,10,28,34,63,38,3,26,1668957,16,1668961,14,1667953,14,
+1584901,2,1599031,12,8,1,1668979,14,1,1310721,2,15,26,1310721,4,18,
+1310721,2,1,28,1310721,4,1310721,2,1835009,40,1669027,16,1966081,1310721,4,1579069,
+12,1648169,12,8,1597071,12,8,1,1667723,12,1669051,14,1,1310721,2,1,
+26,1310721,4,18,1310721,2,21,28,1310721,4,1310721,2,1835009,40,1669099,16,
+1966081,1310721,4,1579069,12,1584845,2,1310721,2,15,26,4,1648169,12,8,1597071,
+12,8,1584887,2,1599031,12,8,1310721,2,5,26,1662195,12,10,3,6,
+10,4,8,1647757,12,8,1310721,2,5,26,2,1605077,12,8,1584889,2,
+1599031,12,8,1310721,2,1589535,12,10,3,6,10,4,8,17,1589235,12,
+8,1310721,2,11,26,1584857,2,10,3,6,10,4,8,1310721,2,7,
+26,1606761,12,10,3,6,10,4,8,1667563,12,8,1310721,2,13,26,
+1584857,2,10,3,6,10,4,8,1310721,2,9,26,1606761,12,10,3,
+6,10,4,8,1584933,2,1598649,12,1669587,16,1597071,12,8,1310721,2,3,
+26,1589535,12,10,3,6,10,4,8,15,1589235,12,8,1310721,2,2,
+1584837,2,1589317,12,8,1310721,2,7,26,2,1607393,12,8,1584857,1310721,2,
+11,26,2,10,3,6,10,4,8,1667563,12,8,1310721,2,9,26,
+2,1310721,2,13,26,2,1310721,2,3,26,2,1584857,2,1310721,2,15,
+26,2,1669575,14,101,110,100,115,32,116,104,101,32,98,114,97,
+110,99,104,101,115,32,111,102,32,97,110,32,105,102,32,105,
+110,32,100,105,102,102,101,114,101,110,116,32,115,116,97,116,
+101,115,0,1669481,1615115,12,8,1670119,14,1609759,1,10,3,6,10,4,
+8,1310721,2,13,26,2,1669637,16,1507841,1310721,2,9,26,2,26,1610727,
+12,8,1310721,2,11,26,2,1669671,16,1507841,1310721,2,7,26,2,26,
+1610727,12,8,1310721,2,15,26,2,1669779,14,101,110,100,115,32,116,
+104,101,32,98,114,97,110,99,104,101,115,32,111,102,32,97,
+110,32,105,102,32,105,110,32,100,105,102,102,101,114,101,110,
+116,32,115,116,97,116,101,115,0,1669685,1611455,12,8,1310721,2,13,
+26,2,1669833,16,1507841,1310721,2,9,26,2,26,1310721,2,15,26,2,
+3,1613039,12,8,1310721,2,17,26,1,10,3,6,10,4,8,1310721,
+2,11,26,2,1669919,16,1310721,2,17,26,1507841,1310721,2,7,26,2,
+26,1310721,2,15,26,2,1,1613039,12,10,3,6,10,4,8,1310721,
+2,17,26,2,1670037,16,1310721,2,19,26,1589535,12,10,3,6,10,
+4,8,15,1589235,12,8,1310721,2,2,1584837,2,1589317,12,8,1507841,1310721,
+2,7,26,2,26,1310721,2,15,26,2,3,1613039,12,8,1310721,2,
+19,26,2,1584837,2,1589317,12,8,1670053,14,1310721,2,2,1584837,2,1589317,
+12,8,1584857,1310721,2,13,26,2,1670075,16,3,1670107,14,1310721,2,11,
+26,2,1,6,1,10,28,34,63,38,1,10,28,10,3,6,
+10,4,8,1310721,2,7,26,2,1607311,12,8,1,1670143,14,1,1310721,
+2,21,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,
+1670191,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1552897,
+1584867,2,17,30,26,1310721,2,5,26,4,1584867,2,121,40,3,36,
+1670305,16,1670297,14,108,111,111,112,115,32,110,101,115,116,101,100,
+32,116,111,111,32,100,101,101,112,108,121,0,1670249,1585585,12,8,
+1310721,2,5,26,2,1,26,1310721,2,2,10,3,6,10,4,8,
+1310721,2,5,26,2,3,26,1,10,3,6,10,4,8,1310721,2,
+5,26,2,5,26,1584849,2,10,3,6,10,4,8,1310721,2,5,
+26,2,7,26,1310721,2,3,26,2,10,3,6,10,4,8,1310721,
+2,5,26,2,9,26,1584859,2,10,3,6,10,4,8,1310721,2,
+5,26,2,11,26,1584845,2,10,3,6,10,4,8,1310721,2,5,
+26,2,13,26,1609629,2,10,3,6,10,4,8,1584867,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1,1670557,14,1,1310721,2,
+7,26,1310721,4,18,1310721,2,15,28,1310721,4,1310721,2,1835009,40,1670605,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1,1310721,
+2,13,26,4,1584867,1,6,2,1,6,-1,26,5,6,4,10,
+8,8,1310721,2,5,26,1552897,1584867,2,17,30,26,10,3,6,10,
+4,8,1310721,2,11,26,1310721,2,5,26,2,11,26,2,10,3,
+6,10,4,8,1609759,1,10,3,6,10,4,8,1310721,2,3,26,
+2,1,40,3,36,1670787,16,1507841,1310721,2,3,26,2,26,1610727,12,
+8,1310721,2,7,26,1567233,1310721,2,5,26,2,13,26,2,26,10,
+3,6,10,4,8,1310721,2,9,26,1567233,1609629,2,26,10,3,6,
+10,4,8,1310721,2,7,26,2,1310721,2,9,26,2,40,1670979,16,
+1310721,2,7,26,2,3,26,1610727,12,8,1310721,2,7,26,1310721,2,
+7,26,2,7,26,7,1310721,2,7,26,2,5,26,2,1310721,2,
+7,26,2,3,26,2,28,30,26,10,3,6,10,4,8,1670855,
+14,1310721,2,11,26,2,1671103,14,108,101,97,118,101,115,32,116,
+104,101,32,108,111,111,112,32,105,110,32,100,105,102,102,101,
+114,101,110,116,32,115,116,97,116,101,115,32,111,110,32,100,
+105,102,102,101,114,101,110,116,32,112,97,116,104,115,0,1670993,
+1611455,12,8,1584857,1609759,2,1,10,40,10,3,6,10,4,8,1310721,
+2,7,26,1567233,1310721,2,5,26,2,13,26,2,26,10,3,6,
+10,4,8,1310721,2,7,26,2,1310721,2,9,26,2,40,1671471,16,
+1310721,2,7,26,2,3,26,1310721,2,11,26,2,1,1613039,12,1671343,
+16,1310721,2,7,26,2,1,26,2,1584837,2,1589317,12,8,1310721,2,
+7,26,2,3,26,1310721,2,11,26,2,3,1613039,12,8,1310721,2,
+13,26,1589535,12,1310721,2,13,26,2,1588385,12,10,3,6,10,4,
+8,15,1589235,12,8,1671393,14,1310721,2,13,26,1310721,2,7,26,2,
+1,26,2,1310721,2,13,26,2,1588385,12,10,3,6,10,4,8,
+1310721,2,7,26,1310721,2,7,26,2,7,26,7,1310721,2,7,26,
+2,5,26,2,1310721,2,7,26,2,3,26,2,28,30,26,10,
+3,6,10,4,8,1671175,14,1310721,2,2,1,40,3,36,1671505,16,
+1310721,2,2,1584837,2,1589317,12,8,1310721,2,3,26,2,1,40,3,
+36,1671559,16,1507841,1310721,2,3,26,2,26,1310721,2,11,26,2,3,
+1613039,12,8,1310721,2,13,26,2,1584837,2,1588737,12,8,1609629,1310721,2,
+5,26,2,13,26,2,10,3,6,10,4,8,1,1671617,14,1,
+1310721,2,15,26,1310721,4,18,1310721,2,13,28,1310721,4,1310721,2,1835009,
+40,1671665,16,1966081,1310721,4,1579069,12,1584837,2,1310721,2,4,3,1,10,
+28,1310721,2,7,26,4,1,1310721,2,11,26,4,1648169,12,8,1597071,
+12,8,1310721,2,5,26,1606761,12,10,3,6,10,4,8,1584887,2,
+1599031,12,8,1582577,2,3,28,1,6,1,10,28,34,63,38,3,
+26,1671813,16,1582579,2,1,6,1,10,28,34,63,38,1,10,28,
+1671815,14,1,1671941,16,1597931,12,8,1584799,2,9,28,1,6,1,10,
+28,34,63,38,3,26,1671913,16,1584801,2,1584889,2,28,1,6,1,
+10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,1,
+10,28,1671915,14,1,1671941,16,1310721,2,11,26,3,10,3,6,10,
+4,8,1310721,2,9,26,1662195,12,10,3,6,10,4,8,1647757,12,
+8,1310721,2,9,26,2,1605077,12,8,1584889,2,1599031,12,8,1310721,2,
+3,26,1589535,12,10,3,6,10,4,8,17,1589235,12,8,1310721,2,
+11,26,2,1,6,1,10,28,34,63,38,3,26,1672093,16,1584857,
+2,1,6,1,10,28,34,63,38,1,10,28,1672095,14,1,1672123,
+16,1310721,2,7,26,1606761,12,10,3,6,10,4,8,1310721,2,2,
+1310721,2,5,26,2,1670157,12,8,1667563,12,8,1310721,2,5,26,2,
+1613533,12,8,1310721,2,2,1589453,12,8,1310721,2,3,26,2,1310721,2,
+7,26,2,1670571,12,8,1310721,2,5,26,2,1607311,12,8,1,1672229,
+14,1,1310721,2,13,26,1310721,4,18,1310721,2,19,28,1310721,4,1310721,
+2,1835009,40,1672277,16,1966081,1310721,4,1579069,12,1584845,2,1310721,2,4,3,
+1,10,28,1310721,2,5,26,4,1,1310721,2,17,26,4,1648169,12,
+8,1597071,12,8,1584887,2,1599031,12,8,1584849,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1584929,2,1598649,12,1672389,16,1668993,12,8,
+1672505,14,1637143,12,1672409,16,3,1667723,12,8,1672505,14,1584901,2,1598497,12,
+1,6,1,10,28,34,63,38,3,26,1672495,16,1310721,2,15,26,
+1662195,12,10,3,6,10,4,8,1647757,12,8,9,1589235,12,8,1310721,
+2,15,26,2,1623627,12,8,1584901,2,1599031,12,8,1310721,2,3,26,
+1606761,12,10,3,6,10,4,8,1310721,2,7,26,1584837,2,10,3,
+6,10,4,8,1584901,2,1598497,12,1,6,1,10,28,34,63,38,
+3,26,1672825,16,1582577,2,3,28,1,6,1,10,28,34,63,38,
+3,26,1672647,16,1582579,2,1,6,1,10,28,34,63,38,1,10,
+28,1672649,14,1,1672775,16,1597931,12,8,1584799,2,9,28,1,6,1,
+10,28,34,63,38,3,26,1672747,16,1584801,2,1584901,2,28,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1672749,14,1,1672775,16,1310721,2,17,26,3,10,3,6,
+10,4,8,1310721,2,15,26,1662195,12,10,3,6,10,4,8,1647757,
+12,8,1310721,2,15,26,2,1605077,12,8,1672855,14,3,1589149,12,8,
+1310721,2,17,26,3,10,3,6,10,4,8,1584901,2,1599031,12,8,
+1310721,2,9,26,1589535,12,10,3,6,10,4,8,17,1589235,12,8,
+1310721,2,17,26,2,1,6,1,10,28,34,63,38,3,26,1672961,
+16,1584857,2,1,6,1,10,28,34,63,38,1,10,28,1672963,14,
+1,1672991,16,1310721,2,5,26,1606761,12,10,3,6,10,4,8,1310721,
+2,11,26,1589535,12,10,3,6,10,4,8,15,1589235,12,8,1310721,
+2,13,26,1584837,2,10,3,6,10,4,8,1584889,2,1598497,12,1,
+6,1,10,28,34,63,38,3,26,1673133,16,1310721,2,15,26,1662195,
+12,10,3,6,10,4,8,1647757,12,8,9,1589235,12,8,1310721,2,
+15,26,2,1623627,12,8,1584889,2,1599031,12,8,1310721,2,7,26,2,
+1589453,12,8,1310721,2,11,26,2,1584837,2,1589317,12,8,1310721,2,13,
+26,2,1310721,2,3,26,2,1670157,12,8,1667563,12,8,1310721,2,3,
+26,2,1613533,12,8,1310721,2,13,26,2,1589453,12,8,1310721,2,9,
+26,2,1310721,2,5,26,2,1670571,12,8,1310721,2,3,26,2,1607311,
+12,8,1310721,2,2,1606489,12,8,1584849,1,6,2,1,6,-1,26,
+5,6,4,10,8,8,1,1673333,14,1,1310721,2,19,26,1310721,4,
+18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1673381,16,1966081,1310721,4,
+1579069,12,1648169,12,8,1597071,12,8,1584901,2,1599031,12,8,1584867,2,1584869,
+2,10,40,3,36,1673507,16,1673493,14,98,114,101,97,107,32,111,
+117,116,115,105,100,101,32,97,32,108,111,111,112,32,111,114,
+32,97,32,115,119,105,116,99,104,0,1673427,1585679,12,8,1,1673759,
+14,1310721,2,1552897,1584867,2,3,28,17,30,26,10,3,6,10,4,
+8,1310721,2,2,9,26,2,1584859,2,28,1,6,1,10,28,34,
+63,38,1,10,28,1673675,16,1673661,14,98,114,101,97,107,32,99,
+97,110,39,116,32,108,101,97,118,101,32,97,32,98,108,111,
+99,107,32,101,120,112,114,101,115,115,105,111,110,0,1673587,1585679,
+12,8,1,1673759,14,1310721,2,2,5,26,2,3,26,1,1605463,12,
+8,1584857,2,1673721,16,1589535,12,1610135,12,8,1673727,14,1589535,12,8,15,
+1589235,12,8,1584857,1,10,3,6,10,4,8,1,1673759,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,
+1673807,16,1966081,1310721,4,1579069,12,1584867,2,3,28,1310721,2,4,1648169,12,
+8,1597071,12,8,1584901,2,1599031,12,8,1310721,2,2,1584869,2,40,3,
+36,1673935,16,1552897,1310721,2,2,17,30,26,2,3,1,10,28,28,
+1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,
+63,38,1,10,28,1673937,14,1,1673975,16,1310721,2,1,6,2,1,
+6,-1,26,5,6,4,10,8,8,1673843,14,1310721,2,2,1584869,2,
+40,1674057,16,1674043,14,99,111,110,116,105,110,117,101,32,111,117,
+116,115,105,100,101,32,97,32,108,111,111,112,0,1673995,1585679,12,
+8,1,1674333,14,1310721,2,3,26,1552897,1310721,2,2,17,30,26,10,
+3,6,10,4,8,1310721,2,3,26,2,9,26,2,1584859,2,28,
+1,6,1,10,28,34,63,38,1,10,28,1674237,16,1674223,14,99,
+111,110,116,105,110,117,101,32,99,97,110,39,116,32,108,101,
+97,118,101,32,97,32,98,108,111,99,107,32,101,120,112,114,
+101,115,115,105,111,110,0,1674143,1585679,12,8,1,1674333,14,1310721,2,
+3,26,2,7,26,2,1613533,12,8,1310721,2,3,26,2,5,26,
+2,3,26,1,1605463,12,8,1310721,2,3,26,2,1,26,2,1589453,
+12,8,1584857,1,10,3,6,10,4,8,1,1674333,14,1,1310721,2,
+5,26,1310721,4,18,1310721,2,7,28,1310721,4,1310721,2,1835009,40,1674381,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1584845,2,
+1310721,2,5,26,4,1310721,2,2,1607393,12,8,1584857,1310721,2,3,26,
+2,10,3,6,10,4,8,1584849,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1584893,2,1598497,12,1,6,1,10,28,34,63,
+38,3,26,1674561,16,1584949,2,1598649,12,1,6,1,10,28,34,63,
+38,3,26,1,6,1,10,28,34,63,38,1,10,28,1674563,14,
+1,1674621,16,1584951,2,1598649,12,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1674623,14,1,1674705,
+16,1582577,2,1,28,1,6,1,10,28,34,63,38,3,26,1674695,
+16,1674683,14,109,105,115,115,105,110,103,32,125,0,1674663,1586063,12,
+8,1674705,14,1666771,12,8,1674475,14,1310721,2,5,26,2,1606489,12,8,
+1584849,1,6,2,1,6,-1,26,5,6,4,10,8,8,1584857,2,
+1674775,16,1589535,12,1610135,12,8,15,1589235,12,8,1584857,1,10,3,6,
+10,4,8,1,1674799,14,1,1310721,2,7,26,1310721,4,18,1310721,2,
+23,28,1310721,4,1310721,2,1835009,40,1674847,16,1966081,1310721,4,1579069,12,1584845,
+2,1310721,2,4,3,1,10,28,1310721,2,11,26,4,3,1,10,
+28,1310721,2,21,26,4,1648169,12,8,1597071,12,8,1584887,2,1599031,12,
+8,1310721,2,5,26,1662195,12,10,3,6,10,4,8,1647757,12,8,
+1310721,2,5,26,2,1605077,12,8,1584889,2,1599031,12,8,1584849,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1310721,2,3,26,1,
+1603891,12,10,3,6,10,4,8,1584851,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1467905,1310721,2,3,26,2,26,2,1590069,12,
+8,5,1589235,12,8,1310721,2,9,26,1584857,2,10,3,6,10,4,
+8,1310721,2,7,26,1606761,12,10,3,6,10,4,8,3,1,10,
+28,1310721,2,7,26,2,1670157,12,8,1584891,2,1599031,12,8,1584893,2,
+1598497,12,1,6,1,10,28,34,63,38,3,26,1675871,16,1582577,2,
+1,28,1,6,1,10,28,34,63,38,3,26,1675265,16,1675253,14,
+109,105,115,115,105,110,103,32,125,0,1675233,1586063,12,8,1675871,14,
+1584949,2,1598649,12,1675587,16,1597071,12,8,1310721,2,17,26,1,10,3,
+6,10,4,8,3,1675475,16,1310721,2,19,26,1665803,12,10,3,6,
+10,4,8,1467905,1310721,2,3,26,2,26,2,1590069,12,8,3,1589235,
+12,8,1310721,2,19,26,2,1589149,12,8,29,1589235,12,8,1310721,2,
+17,26,1589535,12,1310721,2,17,26,2,1588385,12,10,3,6,10,4,
+8,17,1589235,12,8,1584899,2,1598801,12,1,6,1,10,28,34,63,
+38,3,26,1675471,16,1675475,14,1675305,14,1584915,2,1599031,12,8,1310721,2,
+15,26,1589535,12,10,3,6,10,4,8,15,1589235,12,8,1310721,2,
+17,26,2,1584837,2,1588737,12,8,1310721,2,7,26,2,1310721,2,9,
+26,2,1674347,12,8,1310721,2,15,26,2,1584837,2,1589317,12,8,1675867,
+14,1584951,2,1598649,12,1675805,16,1597071,12,8,1584915,2,1599031,12,8,1310721,
+2,11,26,2,1,40,3,36,1675699,16,1675691,14,97,32,115,119,
+105,116,99,104,32,104,97,115,32,111,110,101,32,100,101,102,
+97,117,108,116,0,1675641,1585679,12,8,1310721,2,13,26,1589535,12,10,
+3,6,10,4,8,15,1589235,12,8,1310721,2,11,26,1584837,2,10,
+3,6,10,4,8,1310721,2,7,26,2,1310721,2,9,26,2,1674347,
+12,8,1310721,2,13,26,2,1584837,2,1589317,12,8,1675867,14,1675859,14,
+101,120,112,101,99,116,101,100,32,99,97,115,101,32,111,114,
+32,100,101,102,97,117,108,116,0,1675809,1586063,12,8,1675165,14,1597071,
+12,8,1310721,2,7,26,2,1607393,12,8,1584857,1310721,2,9,26,2,
+10,3,6,10,4,8,1310721,2,11,26,2,1,40,3,36,1675981,
+16,1310721,2,11,26,2,1589453,12,8,3,1,10,28,3,1,10,
+28,1670571,12,8,1676039,14,1310721,2,21,26,1589535,12,10,3,6,10,
+4,8,15,1589235,12,8,1310721,2,21,26,2,1310721,2,7,26,2,
+1670571,12,8,1310721,2,7,26,2,1607311,12,8,1310721,2,2,1606489,12,
+8,1584849,1,6,2,1,6,-1,26,5,6,4,10,8,8,1,
+1676103,14,1,1310721,2,23,26,1310721,4,18,1310721,2,3,28,1310721,4,
+1310721,2,1835009,40,1676151,16,1966081,1310721,4,1579069,12,1648169,12,8,1597071,12,
+8,1584865,2,1,6,1,10,28,34,63,38,3,26,1676255,16,1676247,
+14,114,101,116,117,114,110,32,111,117,116,115,105,100,101,32,
+97,32,102,117,110,99,116,105,111,110,0,1676195,1585679,12,8,1584859,
+2,1676351,16,1676343,14,114,101,116,117,114,110,32,99,97,110,39,
+116,32,108,101,97,118,101,32,97,32,98,108,111,99,107,32,
+101,120,112,114,101,115,115,105,111,110,0,1676267,1585679,12,8,1584901,
+2,1598497,12,1676393,16,1,1589149,12,8,1310721,2,1,10,3,6,10,
+4,8,1676621,14,1310721,2,1662195,12,10,3,6,10,4,8,1647757,12,
+8,1584885,2,1584983,2,28,1,6,1,10,28,34,63,38,3,26,
+1676503,16,1676483,14,114,101,116,117,114,110,32,118,97,108,117,101,
+0,1676457,1584983,2,1584987,2,1633925,12,8,1676621,14,1584885,2,1676569,16,1584885,
+2,1584987,2,1630621,12,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1676571,14,1,1676621,16,1676605,
+14,114,101,116,117,114,110,32,118,97,108,117,101,0,1676579,1584885,
+2,1584987,2,1633925,12,8,1584901,2,1599031,12,8,1310721,2,2,1621929,12,
+8,3,1,1605463,12,8,1584861,1584837,2,1584861,2,1588385,12,10,3,6,
+10,4,8,2097153,3,28,1589149,12,8,15,1589235,12,8,1584857,1,10,
+3,6,10,4,8,1,1676723,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,3,28,1310721,4,1310721,2,1835009,40,1676771,16,1966081,1310721,4,1579069,
+12,1584853,2,1310721,2,4,1648169,12,8,1597071,12,8,1584853,1,10,3,
+6,10,4,8,1667563,12,8,1584853,1310721,2,2,10,3,6,10,4,
+8,1,1676843,14,1,1310721,2,3,26,1310721,4,18,1310721,2,21,28,
+1310721,4,1310721,2,1835009,40,1676891,16,1966081,1310721,4,1579069,12,1,1310721,2,
+4,1,1310721,2,3,26,4,1554945,1310721,2,13,26,4,1554945,129,26,
+1310721,2,15,26,4,1554945,257,26,1310721,2,17,26,4,1554945,769,26,
+1310721,2,19,26,4,1584891,2,1599031,12,8,1584893,2,1598497,12,1,6,
+1,10,28,34,63,38,3,26,1678951,16,1582577,2,1,28,1,6,
+1,10,28,34,63,38,3,26,1677103,16,1677095,14,117,110,116,101,
+114,109,105,110,97,116,101,100,32,97,115,109,32,98,108,111,
+99,107,0,1677049,1586063,12,8,1582577,2,3,28,1,6,1,10,28,
+34,63,38,3,26,1677155,16,1582579,2,1589149,12,8,1597071,12,8,1676981,
+14,1582577,2,7,28,1,6,1,10,28,34,63,38,3,26,1677207,
+16,1582579,2,1590177,12,8,1597071,12,8,1676981,14,1584917,2,1598497,12,1677325,
+16,1597071,12,8,1582577,2,3,28,1,6,1,10,28,34,63,38,
+1,10,28,1677305,16,1677297,14,35,32,110,101,101,100,115,32,97,
+32,110,117,109,98,101,114,0,1677263,1586063,12,8,1582579,2,1588955,12,
+8,1597071,12,8,1676981,14,1584919,2,1598497,12,1677447,16,1597071,12,8,1582577,
+2,3,28,1,6,1,10,28,34,63,38,3,26,1677405,16,1582581,
+2,1,6,1,10,28,34,63,38,1,10,28,1677407,14,1,1677435,
+16,1,1582579,2,28,1589149,12,8,1597071,12,8,1677443,14,29,1589235,12,
+8,1676981,14,1584915,2,1598497,12,1677637,16,1597071,12,8,1310721,2,2,129,
+40,3,36,1677535,16,1677527,14,116,111,111,32,109,97,110,121,32,
+97,115,109,32,108,97,98,101,108,115,0,1677487,1585585,12,8,1310721,
+2,13,26,2,1310721,2,2,26,1599321,12,10,3,6,10,4,8,
+1310721,2,15,26,2,1310721,2,2,26,1584837,2,10,3,6,10,4,
+8,1310721,2,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1676981,14,1582579,2,1,26,2,1677707,16,1582579,2,3,26,2,1,6,
+1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,38,
+1,10,28,1677709,14,1,1677779,16,1310721,2,9,26,1582579,2,1,26,
+2,1600613,12,10,3,6,10,4,1,40,3,36,1,6,1,10,
+28,34,63,38,1,10,28,1677781,14,1,1677811,16,1310721,2,9,26,
+2,1589235,12,8,1597071,12,8,1676981,14,1582577,2,5,28,1,6,1,
+10,28,34,63,38,1,10,28,1677891,16,1677883,14,98,97,100,32,
+116,111,107,101,110,32,105,110,32,97,115,109,0,1677849,1586063,12,
+8,1310721,2,5,26,1582579,2,1603687,12,10,3,6,10,4,8,1310721,
+2,5,26,2,1,40,3,36,1678001,16,1472001,1310721,2,5,26,2,
+26,3,10,3,6,10,4,8,1467905,1310721,2,5,26,2,26,2,
+1590069,12,8,1597071,12,8,1676981,14,1310721,2,7,26,3,1,10,28,
+10,3,6,10,4,8,1310721,2,5,26,1,10,3,6,10,4,
+8,1310721,2,5,26,2,1310721,2,2,40,1678195,16,1310721,2,13,26,
+2,1310721,2,5,26,2,26,2,1582579,2,28,1,6,1,10,28,
+34,63,38,3,26,1678157,16,1310721,2,7,26,1310721,2,5,26,2,
+10,3,6,10,4,8,1310721,2,5,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1678051,14,1310721,2,7,26,2,1,40,
+3,36,1678257,16,1310721,2,15,26,2,1310721,2,7,26,2,26,2,
+1589149,12,8,1597071,12,8,1676981,14,1310721,2,11,26,1582579,2,1587809,12,
+10,3,6,10,4,8,1310721,2,11,26,2,1,40,3,36,1678373,
+16,1417729,1310721,2,11,26,2,26,2,13,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1678375,14,1,1678415,16,45,1425921,1310721,2,11,26,2,26,2,26,1589235,
+12,8,1597071,12,8,1676981,14,1310721,2,11,26,2,1,40,3,36,
+1678505,16,1417729,1310721,2,11,26,2,26,2,3,28,1,6,1,10,
+28,34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,
+10,28,1678507,14,1,1678579,16,1417729,1310721,2,11,26,2,26,2,11,
+28,1,6,1,10,28,34,63,38,1,10,28,1,6,1,10,
+28,34,63,38,1,10,28,1678581,14,1,1678617,16,1425921,1310721,2,11,
+26,2,26,2,1589149,12,8,1597071,12,8,1676981,14,1310721,2,11,26,
+2,1,40,3,36,1678705,16,1417729,1310721,2,11,26,2,26,2,3,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1678707,14,1,1678737,16,1310721,2,11,26,2,
+1589741,12,8,1597071,12,8,1676981,14,1310721,2,3,26,2,501,40,3,
+36,1678831,16,1678823,14,116,111,111,32,109,97,110,121,32,97,115,
+109,32,108,97,98,101,108,32,114,101,102,101,114,101,110,99,
+101,115,0,1678763,1585585,12,8,1310721,2,17,26,2,1310721,2,3,26,
+2,26,1582579,2,10,3,6,10,4,8,1310721,2,19,26,2,1310721,
+2,3,26,2,26,1589535,12,10,3,6,10,4,8,1310721,2,3,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1597071,12,
+8,1676981,14,1597071,12,8,1310721,2,5,26,1,10,3,6,10,4,
+8,1310721,2,5,26,2,1310721,2,3,26,2,40,1679405,16,1310721,2,
+7,26,3,1,10,28,10,3,6,10,4,8,1310721,2,9,26,
+1,10,3,6,10,4,8,1310721,2,9,26,2,1310721,2,2,40,
+1679219,16,1310721,2,13,26,2,1310721,2,9,26,2,26,2,1310721,2,
+17,26,2,1310721,2,5,26,2,26,2,28,1,6,1,10,28,
+34,63,38,3,26,1679181,16,1310721,2,7,26,1310721,2,9,26,2,
+10,3,6,10,4,8,1310721,2,9,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1679055,14,1310721,2,7,26,2,1,40,
+1679313,16,1310721,2,17,26,2,1310721,2,5,26,2,26,2,1679305,14,
+117,110,107,110,111,119,110,32,110,97,109,101,32,105,110,32,
+97,115,109,0,1679265,1585849,12,8,1310721,2,19,26,2,1310721,2,5,
+26,2,26,2,1310721,2,15,26,2,1310721,2,7,26,2,26,2,
+1589317,12,8,1310721,2,5,26,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1678979,14,1,1679413,14,1,1310721,2,21,26,1310721,4,
+18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1679461,16,1966081,1310721,4,
+1579069,12,1597071,12,8,1676857,12,8,1584883,1,10,3,6,10,4,8,
+1,1679497,14,1,1310721,2,1,26,1310721,4,18,1310721,2,7,28,1310721,
+4,1310721,2,1835009,40,1679545,16,1966081,1310721,4,1579069,12,1,1310721,2,4,
+1,1310721,2,3,26,4,1584891,2,1598497,12,1,6,1,10,28,34,
+63,38,3,26,1679631,16,1679623,14,101,120,112,101,99,116,101,100,
+32,123,0,1679601,1586063,12,8,1597071,12,8,3,1680053,16,1582577,2,1,
+28,1,6,1,10,28,34,63,38,3,26,1679725,16,1679717,14,117,
+110,116,101,114,109,105,110,97,116,101,100,32,113,117,111,116,
+101,0,1679679,1586063,12,8,1584891,2,1598497,12,1679771,16,1310721,2,3,26,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1584893,2,1598497,
+12,1679855,16,1310721,2,3,26,2,1,6,1,10,28,34,63,38,
+3,26,1679821,16,1680053,14,1310721,2,3,26,1,6,2,1,6,-1,
+26,5,6,4,10,8,8,1310721,2,2,5401,40,3,36,1679915,16,
+1679907,14,113,117,111,116,101,32,116,111,111,32,108,111,110,103,
+0,1679877,1585585,12,8,1524225,1310721,2,2,7,30,26,1582577,2,10,3,
+6,10,4,8,1524225,1310721,2,2,7,30,3,26,26,1582579,2,10,
+3,6,10,4,8,1524225,1310721,2,2,7,30,5,26,26,1582583,2,
+10,3,6,10,4,8,1310721,2,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1597071,12,8,1679637,14,1597071,12,8,1310721,2,5,
+26,1310721,2,2,7,30,3,26,1579923,12,10,3,6,10,4,8,
+1310721,2,5,26,2,1,26,1310721,2,2,10,3,6,10,4,8,
+1310721,2,5,26,2,3,26,1524225,1310721,2,2,7,30,1574337,12,8,
+1310721,2,5,26,2,1680177,14,1,1310721,2,7,26,1310721,4,18,1310721,
+2,7,28,1310721,4,1310721,2,1835009,40,1680225,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,1,26,2,7,30,3,26,1310721,2,3,
+26,4,1310721,2,3,26,2,1579923,12,1310721,2,5,26,4,1310721,2,
+5,26,2,1310721,2,2,1310721,2,3,26,2,1574337,12,8,1310721,2,
+5,26,2,1680333,14,1,1310721,2,7,26,1310721,4,18,1310721,2,7,
+28,1310721,4,1310721,2,1835009,40,1680381,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,1,26,2,7,30,3,26,1310721,2,3,26,4,
+1310721,2,3,26,2,1579923,12,1310721,2,5,26,4,1310721,2,5,26,
+2,1310721,2,2,1310721,2,3,26,2,1574337,12,8,1310721,2,5,26,
+2,1680489,14,1,1310721,2,7,26,1310721,4,18,1310721,2,7,28,1310721,
+4,1310721,2,1835009,40,1680537,16,1966081,1310721,4,1579069,12,1310721,2,3,26,
+4,1310721,2,4,1,1310721,2,5,26,4,1310721,2,5,26,2,1310721,
+2,3,26,2,40,1680655,16,1310721,2,2,1310721,2,5,26,2,26,
+2,1588955,12,8,1310721,2,5,26,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1680565,14,1,1680663,14,1,1310721,2,7,26,1310721,
+4,18,1310721,2,9,28,1310721,4,1310721,2,1835009,40,1680711,16,1966081,1310721,
+4,1579069,12,1597071,12,8,1310721,2,1679511,12,10,3,6,10,4,8,
+1310721,2,3,26,1589535,12,10,3,6,10,4,8,15,1589235,12,8,
+1310721,2,5,26,1584837,2,10,3,6,10,4,8,1310721,2,7,26,
+1310721,2,2,1,26,2,7,30,3,26,10,3,6,10,4,8,
+1310721,2,2,1310721,2,7,26,2,1680503,12,8,1310721,2,2,1580623,12,
+8,1310721,2,3,26,2,1584837,2,1589317,12,8,1310721,2,5,26,2,
+1589149,12,8,1584963,2,1589915,12,8,1584883,3,10,3,6,10,4,8,
+1,1680937,14,1,1310721,2,9,26,1310721,4,18,1310721,2,7,28,1310721,
+4,1310721,2,1835009,40,1680985,16,1966081,1310721,4,1579069,12,1310721,2,4,1,
+1310721,2,3,26,4,5,1310721,2,2,1,1,1590943,12,8,1597071,12,
+8,1582577,2,1,28,1,6,1,10,28,34,63,38,1,10,28,
+1681281,16,1310721,2,3,26,2,5401,40,3,36,1681127,16,1681119,14,116,
+111,111,32,109,97,110,121,32,116,111,107,101,110,115,0,1681087,
+1585585,12,8,1524225,1310721,2,3,26,2,7,30,26,1582577,2,10,3,
+6,10,4,8,1524225,1310721,2,3,26,2,7,30,3,26,26,1582579,
+2,10,3,6,10,4,8,1524225,1310721,2,3,26,2,7,30,5,
+26,26,1582583,2,10,3,6,10,4,8,1310721,2,3,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1597071,12,8,1681027,14,
+1592371,12,8,1310721,2,5,26,1310721,2,3,26,2,7,30,3,26,
+1579923,12,10,3,6,10,4,8,1310721,2,5,26,2,1,26,1310721,
+2,3,26,2,10,3,6,10,4,8,1310721,2,5,26,2,3,
+26,1524225,1310721,2,3,26,2,7,30,1574337,12,8,1310721,2,5,26,
+2,1681417,14,1,1310721,2,7,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1681465,16,1966081,1310721,4,1579069,12,1310721,2,4,3,
+1310721,2,2,3,3,1590943,12,8,1597071,12,8,1,1681503,14,1,1310721,
+2,3,26,1310721,4,18,1310721,2,13,28,1310721,4,1310721,2,1835009,40,
+1681551,16,1966081,1310721,4,1579069,12,8181,1310721,2,4,8181,1579923,12,1310721,2,
+3,26,4,1,1310721,2,5,26,4,1573227,12,1,6,1,10,28,
+34,63,38,3,26,1682109,16,1310721,2,7,26,1573171,12,511,32,10,
+3,6,10,4,8,1310721,2,7,26,2,193,28,1,6,1,10,
+28,34,63,38,3,26,1681685,16,1682109,14,1310721,2,5,26,2,5,
+38,5,26,1310721,2,2,40,3,36,1681873,16,1310721,2,9,26,1310721,
+2,2,1310721,2,2,26,13,26,1579923,12,10,3,6,10,4,8,
+1310721,2,9,26,2,1310721,2,3,26,2,1310721,2,2,1574337,12,8,
+1310721,2,3,26,2,1580623,12,8,1310721,2,3,26,1310721,2,9,26,
+2,10,3,6,10,4,8,1310721,2,1310721,2,2,1310721,2,2,26,
+13,26,10,3,6,10,4,8,1310721,2,11,26,1310721,2,5,26,
+2,5,38,10,3,6,10,4,8,1310721,2,5,26,2,7,32,
+1,6,1,10,28,34,63,38,3,26,1681981,16,1310721,2,3,26,
+2,1310721,2,11,26,2,26,1,10,3,6,10,4,8,1310721,2,
+3,26,2,1310721,2,11,26,2,26,1310721,2,3,26,2,1310721,2,
+11,26,2,26,2,1310721,2,7,26,2,1310721,2,5,26,2,7,
+32,17,30,48,34,10,3,6,10,4,8,1310721,2,5,26,1,
+6,2,1,6,3,26,5,6,4,10,8,8,1681587,14,1310721,2,
+3,26,2,1310721,2,5,26,2,5,38,26,1310721,2,3,26,2,
+1310721,2,5,26,2,5,38,26,2,1574747,1310721,2,5,26,2,7,
+32,17,30,26,2,3,28,32,10,3,6,10,4,8,1310721,2,
+5,26,2,7,32,1,28,1,6,1,10,28,34,63,38,3,
+26,1682287,16,1310721,2,3,26,2,1310721,2,5,26,2,5,38,26,
+1,10,3,6,10,4,8,1310721,2,3,26,2,1310721,2,5,26,
+2,5,38,3,26,26,1,10,3,6,10,4,8,1310721,2,3,
+26,2,1682347,14,1,1310721,2,13,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1682395,16,1966081,1310721,4,1579069,12,1,1310721,2,
+4,1582577,2,1,28,1,6,1,10,28,34,63,38,1,10,28,
+1682603,16,1585015,2,1598497,12,1682483,16,1310721,2,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1682567,14,1585017,2,1598497,12,1682529,16,1310721,
+2,1,6,2,1,6,-1,26,5,6,4,10,8,8,1682567,14,
+1585019,2,1598497,12,1682567,16,1310721,2,1310721,2,2,5,28,10,3,6,
+10,4,8,1597071,12,8,1310721,2,2,1,10,40,3,36,1682599,16,
+1,1682611,14,1682403,14,1,1682611,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,15,28,1310721,4,1310721,2,1835009,40,1682659,16,1966081,1310721,4,1579069,
+12,1582579,2,1310721,2,4,1,1310721,2,3,26,4,1,1310721,2,5,
+26,4,1,1310721,2,7,26,4,1,1310721,2,9,26,4,1582577,2,
+5,28,1,6,1,10,28,34,63,38,1,10,28,1682757,16,1,
+1684237,14,1597071,12,8,1585015,2,1598497,12,1682781,16,1682361,12,8,1584887,2,
+1598497,12,1,6,1,10,28,34,63,38,3,26,1682819,16,1,1684237,
+14,1597071,12,8,1584889,2,1598497,12,1,6,1,10,28,34,63,38,
+3,26,1683569,16,1310721,2,3,26,3,10,3,6,10,4,8,1310721,
+2,11,26,3,10,3,6,10,4,8,1582577,2,1,28,1,6,
+1,10,28,34,63,38,1,10,28,1683475,16,1584887,2,1598497,12,1682985,
+16,1310721,2,11,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1683465,14,1584889,2,1598497,12,1683073,16,1310721,2,11,26,1,6,
+2,1,6,-1,26,5,6,4,10,8,8,1310721,2,11,26,2,
+1,6,1,10,28,34,63,38,3,26,1683069,16,1683475,14,1683465,14,
+1310721,2,11,26,2,3,28,1,6,1,10,28,34,63,38,3,
+26,1683145,16,1584899,2,1598497,12,1,6,1,10,28,34,63,38,1,
+10,28,1683147,14,1,1683305,16,1310721,2,3,26,2,25,10,40,3,
+36,1683245,16,1310721,2,5,26,1310721,2,5,26,2,1310721,2,7,26,
+2,1310721,2,3,26,2,1310721,2,3,26,2,26,5,28,48,26,
+10,3,6,10,4,8,1310721,2,3,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1310721,2,7,26,1,10,3,6,10,
+4,8,1683465,14,1310721,2,11,26,2,3,28,1,6,1,10,28,
+34,63,38,3,26,1683377,16,1584925,2,1598497,12,1,6,1,10,28,
+34,63,38,1,10,28,1683379,14,1,1683465,16,1597071,12,8,1584941,2,
+1598649,12,1683427,16,1310721,2,7,26,3,10,3,6,10,4,8,1683461,
+14,1584943,2,1598649,12,1683461,16,1310721,2,7,26,5,10,3,6,10,
+4,8,1682901,14,1597071,12,8,1682901,14,1310721,2,3,26,2,25,10,
+40,3,36,1683569,16,1310721,2,5,26,1310721,2,5,26,2,1310721,2,
+7,26,2,1310721,2,3,26,2,1310721,2,3,26,2,26,5,28,
+48,26,10,3,6,10,4,8,1597071,12,8,1584905,2,1598801,12,1683807,
+16,1582577,2,1,28,1,6,1,10,28,34,63,38,1,10,28,
+1683675,16,1584891,2,1598497,12,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1683677,14,1,1683735,16,
+1584901,2,1598497,12,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1683737,14,1,1683807,16,1584925,2,
+1598497,12,1683797,16,1597071,12,8,1584945,2,1598649,12,1683793,16,1310721,2,9,
+26,3,10,3,6,10,4,8,1683587,14,1597071,12,8,1683587,14,1310721,
+2,13,26,1310721,2,2,1587809,12,10,3,6,10,4,8,1310721,2,
+13,26,2,1,40,1683861,16,3,1683899,14,1310721,2,13,26,2,1582509,
+2,40,1,6,1,10,28,34,63,38,1,10,28,1683909,16,3,
+1683973,14,1417729,1310721,2,13,26,2,26,2,3,28,1,6,1,10,
+28,34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,
+10,28,1683983,16,3,1684025,14,1442305,1310721,2,13,26,2,26,2,3,
+32,1,6,1,10,28,34,63,38,1,10,28,1684059,16,1310721,2,
+13,26,1310721,2,2,1589617,12,10,3,6,10,4,8,1442305,1310721,2,
+13,26,2,26,2,5,32,1,6,1,10,28,34,63,38,3,
+26,1684229,16,1434113,1310721,2,13,26,2,26,1310721,2,9,26,2,1310721,
+2,3,26,2,26,1310721,2,3,26,2,26,1310721,2,5,26,2,
+129,30,26,10,3,6,10,4,8,1442305,1310721,2,13,26,2,26,
+1442305,1310721,2,13,26,2,26,2,5,34,513,34,10,3,6,10,
+4,8,1,1684237,14,1,1310721,2,15,26,1310721,4,18,1310721,2,11,
+28,1310721,4,1310721,2,1835009,40,1684285,16,1966081,1310721,4,1579069,12,1310721,2,
+3,26,4,1310721,2,4,1,1310721,2,5,26,4,1585091,2,1310721,2,
+7,26,4,1585089,2,1310721,2,9,26,4,1584991,1,6,2,1,6,
+3,26,5,6,4,10,8,8,1310721,2,2,1310721,2,3,26,2,
+1,1,1590943,12,8,1597071,12,8,1582577,2,1,28,1,6,1,10,
+28,34,63,38,1,10,28,1684625,16,1584891,2,1598497,12,1684485,16,1310721,
+2,5,26,1,6,2,1,6,3,26,5,6,4,10,8,8,
+1684615,14,1584893,2,1598497,12,1684535,16,1310721,2,5,26,1,6,2,1,
+6,-1,26,5,6,4,10,8,8,1684615,14,1310721,2,5,26,2,
+1,10,40,3,36,1684593,16,1584927,2,1598649,12,1,6,1,10,28,
+34,63,38,1,10,28,1684595,14,1,1684615,16,1597071,12,8,1682625,12,
+8,1684401,14,1597071,12,8,1684401,14,1592371,12,8,1584991,1,6,2,1,
+6,-1,26,5,6,4,10,8,8,1585091,1310721,2,7,26,2,10,
+3,6,10,4,8,1585089,1310721,2,9,26,2,10,3,6,10,4,
+8,1,1684715,14,1,1310721,2,11,26,1310721,4,18,1310721,2,3,28,
+1310721,4,1310721,2,1835009,40,1684763,16,1966081,1310721,4,1579069,12,1681517,12,1310721,
+2,4,7,1310721,2,2,1684251,12,8,7,1310721,2,2,1,1,1590943,
+12,8,1597071,12,8,1697867,12,8,1582509,2,1697967,12,8,1592371,12,8,
+1310721,2,2,1580623,12,8,1,1684853,14,1,1310721,2,3,26,1310721,4,
+18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1684901,16,1966081,1310721,4,
+1579069,12,1548801,1584871,2,49,30,26,1310721,2,4,1584871,2,61,40,3,
+36,1685001,16,1684993,14,99,111,109,112,105,108,101,115,32,110,101,
+115,116,101,100,32,116,111,111,32,100,101,101,112,108,121,0,
+1684939,1585585,12,8,1584871,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1310721,2,2,1,26,1584845,2,10,3,6,10,4,8,1310721,
+2,2,3,26,1584847,2,10,3,6,10,4,8,1310721,2,2,5,
+26,1584849,2,10,3,6,10,4,8,1310721,2,2,7,26,1584851,2,
+10,3,6,10,4,8,1310721,2,2,9,26,1584853,2,10,3,6,
+10,4,8,1310721,2,2,11,26,1584855,2,10,3,6,10,4,8,
+1310721,2,2,13,26,1584857,2,10,3,6,10,4,8,1310721,2,2,
+15,26,1584859,2,10,3,6,10,4,8,1310721,2,2,17,26,1584861,
+2,10,3,6,10,4,8,1310721,2,2,19,26,1584863,2,10,3,
+6,10,4,8,1310721,2,2,21,26,1584865,2,10,3,6,10,4,
+8,1310721,2,2,23,26,1584867,2,10,3,6,10,4,8,1310721,2,
+2,25,26,1584869,2,10,3,6,10,4,8,1310721,2,2,27,26,
+1584875,2,10,3,6,10,4,8,1310721,2,2,29,26,1584877,2,10,
+3,6,10,4,8,1310721,2,2,31,26,1584879,2,10,3,6,10,
+4,8,1310721,2,2,33,26,1584881,2,10,3,6,10,4,8,1310721,
+2,2,35,26,1584883,2,10,3,6,10,4,8,1310721,2,2,37,
+26,1584873,2,10,3,6,10,4,8,1310721,2,2,39,26,1584885,2,
+10,3,6,10,4,8,1310721,2,2,41,26,1585009,2,10,3,6,
+10,4,8,1310721,2,2,43,26,1584987,2,10,3,6,10,4,8,
+1310721,2,2,45,26,1584993,5,1574337,12,8,1,1685629,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1685677,
+16,1966081,1310721,4,1579069,12,1584871,1,6,2,1,6,-1,26,5,6,
+4,10,8,8,1310721,2,1548801,1584871,2,49,30,26,10,3,6,10,
+4,8,1584845,1310721,2,2,1,26,2,10,3,6,10,4,8,1584847,
+1310721,2,2,3,26,2,10,3,6,10,4,8,1584849,1310721,2,2,
+5,26,2,10,3,6,10,4,8,1584851,1310721,2,2,7,26,2,
+10,3,6,10,4,8,1584853,1310721,2,2,9,26,2,10,3,6,
+10,4,8,1584855,1310721,2,2,11,26,2,10,3,6,10,4,8,
+1584857,1310721,2,2,13,26,2,10,3,6,10,4,8,1584859,1310721,2,
+2,15,26,2,10,3,6,10,4,8,1584861,1310721,2,2,17,26,
+2,10,3,6,10,4,8,1584863,1310721,2,2,19,26,2,10,3,
+6,10,4,8,1584865,1310721,2,2,21,26,2,10,3,6,10,4,
+8,1584867,1310721,2,2,23,26,2,10,3,6,10,4,8,1584869,1310721,
+2,2,25,26,2,10,3,6,10,4,8,1584875,1310721,2,2,27,
+26,2,10,3,6,10,4,8,1584877,1310721,2,2,29,26,2,10,
+3,6,10,4,8,1584879,1310721,2,2,31,26,2,10,3,6,10,
+4,8,1584881,1310721,2,2,33,26,2,10,3,6,10,4,8,1584883,
+1310721,2,2,35,26,2,10,3,6,10,4,8,1584873,1310721,2,2,
+37,26,2,10,3,6,10,4,8,1584885,1310721,2,2,39,26,2,
+10,3,6,10,4,8,1585009,1310721,2,2,41,26,2,10,3,6,
+10,4,8,1584987,1310721,2,2,43,26,2,10,3,6,10,4,8,
+1584993,1310721,2,2,45,26,5,1574337,12,8,1,1686333,14,1,1310721,2,
+3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,40,1686381,
+16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,1584847,1584845,
+2,10,3,6,10,4,8,1584849,3,10,3,6,10,4,8,1584851,
+1,10,3,6,10,4,8,1584853,1310721,2,2,1686489,16,1582575,2,1,
+6,1,10,28,34,63,38,1,10,28,1686491,14,1,10,3,6,
+10,4,8,1584855,1310721,2,3,26,2,10,3,6,10,4,8,1584885,
+1,10,3,6,10,4,8,1584857,3,10,3,6,10,4,8,1584859,
+1,10,3,6,10,4,8,1584861,1,10,3,6,10,4,8,1584865,
+3,10,3,6,10,4,8,1584869,1584867,2,10,3,6,10,4,8,
+1584875,1,10,3,6,10,4,8,1584877,1,10,3,6,10,4,8,
+1,1686665,14,1,1310721,2,5,26,1310721,4,18,1310721,2,3,28,1310721,
+4,1310721,2,1835009,40,1686713,16,1966081,1310721,4,1579069,12,1310721,1589149,12,8,
+3,1589235,12,8,1584863,1589535,12,10,3,6,10,4,8,29,1589235,12,
+8,1310721,1589149,12,8,5,1589235,12,8,1310721,1589149,12,8,3,1589235,12,
+8,1835009,1589149,12,8,41,1589235,12,8,1310721,2,1589535,12,10,3,6,
+10,4,8,17,1589235,12,8,1966081,1589149,12,8,1310721,1589149,12,8,5,
+1589235,12,8,1584953,2,1589915,12,8,1310721,2,2,1584837,2,1589317,12,8,
+1,1686889,14,1,1310721,2,3,26,1310721,4,18,1310721,2,1,28,1310721,
+4,1310721,2,1835009,40,1686937,16,1966081,1310721,4,1579069,12,1,1589149,12,8,
+1584861,2,1584837,2,1588737,12,8,1310721,1589149,12,8,3,1589235,12,8,1584851,
+2,1589149,12,8,27,1589235,12,8,1310721,1589149,12,8,5,1589235,12,8,
+19,1589235,12,8,1584863,2,1584851,2,1589317,12,8,1584865,1,10,3,6,
+10,4,8,1584845,1584847,2,10,3,6,10,4,8,1,1687073,14,1,
+1310721,2,1,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,
+40,1687121,16,1966081,1310721,4,1579069,12,1584891,2,1599031,12,8,1584893,2,1598497,
+12,1,6,1,10,28,34,63,38,3,26,1687287,16,1582577,2,1,
+28,1,6,1,10,28,34,63,38,3,26,1687277,16,1687269,14,109,
+105,115,115,105,110,103,32,125,32,97,116,32,116,104,101,32,
+101,110,100,32,111,102,32,97,32,102,117,110,99,116,105,111,
+110,0,1687199,1586063,12,8,1666771,12,8,1687131,14,1584847,2,1606191,12,8,
+1584853,2,1687335,16,1584857,2,1,6,1,10,28,34,63,38,1,10,
+28,1687337,14,1,1687455,16,3,3,1605463,12,8,1584855,2,1687455,16,1687447,
+14,97,32,45,62,32,46,117,32,102,117,110,99,116,105,111,
+110,32,104,97,115,32,116,111,32,101,110,100,32,119,105,116,
+104,32,97,32,114,101,116,117,114,110,0,1687363,1586351,12,8,1597071,
+12,8,1,1687469,14,1,1310721,2,1,26,1310721,4,18,1310721,2,169,
+28,1310721,4,1310721,2,1835009,40,1687517,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1,1310721,2,7,26,4,1,1310721,2,9,26,4,1,1310721,2,
+13,26,4,1,1310721,2,163,26,4,1,1310721,2,165,26,4,1597071,
+12,8,1310721,2,3,26,1599321,12,10,3,6,10,4,8,1585009,1,
+10,3,6,10,4,8,1585015,2,1598497,12,1687851,16,1597071,12,8,3,
+1687823,16,1585009,2,17,40,3,36,1687731,16,1687723,14,116,111,111,32,
+109,97,110,121,32,116,121,112,101,32,112,97,114,97,109,101,
+116,101,114,115,0,1687673,1586063,12,8,1584993,1585009,2,26,1599321,12,10,
+3,6,10,4,8,1585009,1,6,2,1,6,3,26,5,6,4,
+10,8,8,1584899,2,1598801,12,1,6,1,10,28,34,63,38,3,
+26,1687819,16,1687823,14,1687647,14,1635147,12,8,1310721,2,165,26,3,10,
+3,6,10,4,8,1310721,2,5,26,1310721,2,3,26,2,1587809,12,
+10,3,6,10,4,8,1310721,2,5,26,2,1,40,1687909,16,3,
+1687947,14,1310721,2,5,26,2,1582509,2,40,1,6,1,10,28,34,
+63,38,1,10,28,1687957,16,3,1688021,14,1417729,1310721,2,5,26,2,
+26,2,3,28,1,6,1,10,28,34,63,38,1,10,28,1,
+6,1,10,28,34,63,38,1,10,28,1688031,16,3,1688073,14,1442305,
+1310721,2,5,26,2,26,2,3,32,1,6,1,10,28,34,63,
+38,1,10,28,1688143,16,1310721,2,5,26,1310721,2,3,26,2,3,
+1,1587311,12,10,3,6,10,4,8,1442305,1310721,2,5,26,2,26,
+1,10,3,6,10,4,8,1584887,2,1599031,12,8,1584889,2,1598497,12,
+1,6,1,10,28,34,63,38,3,26,1689487,16,3,1689487,16,1310721,
+2,11,26,1,10,3,6,10,4,8,1310721,2,115,26,1310721,2,
+7,26,2,26,1584975,2,10,3,6,10,4,8,1584925,2,1598497,12,
+1,6,1,10,28,34,63,38,3,26,1688621,16,1582577,2,9,28,
+1,6,1,10,28,34,63,38,3,26,1688431,16,1582579,2,1584911,2,
+28,1,6,1,10,28,34,63,38,3,26,1688353,16,3,1688405,14,
+1582579,2,1584895,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,
+63,38,1,10,28,1688433,14,1,1688443,16,3,1688595,14,1582577,2,5,
+28,1,6,1,10,28,34,63,38,3,26,1688571,16,1582579,2,1584927,
+2,28,1,6,1,10,28,34,63,38,3,26,1688515,16,3,1688545,
+14,1582579,2,1634911,12,1,6,1,10,28,34,63,38,1,10,28,
+1,6,1,10,28,34,63,38,1,10,28,1688573,14,1,1,6,
+1,10,28,34,63,38,1,10,28,1,6,1,10,28,34,63,
+38,1,10,28,1688623,14,1,1688809,16,1310721,2,115,26,1310721,2,7,
+26,2,26,1635249,12,10,3,6,10,4,8,1310721,2,165,26,3,
+10,3,6,10,4,8,1310721,2,115,26,1310721,2,7,26,2,26,
+2,1629979,12,1688809,16,1688801,14,115,116,114,117,99,116,115,32,97,
+110,100,32,97,114,114,97,121,115,32,97,114,101,32,112,97,
+115,115,101,100,32,98,121,32,112,111,105,110,116,101,114,0,
+1688719,1585679,12,8,1584925,2,1598801,12,1689015,16,1582579,2,1584941,2,28,1,
+6,1,10,28,34,63,38,3,26,1688881,16,1310721,2,11,26,3,
+10,3,6,10,4,8,1689009,14,1582579,2,1584943,2,28,1,6,1,
+10,28,34,63,38,3,26,1688941,16,1310721,2,11,26,5,10,3,
+6,10,4,8,1689009,14,1689001,14,97,32,112,97,114,97,109,101,
+116,101,114,32,116,97,103,32,105,115,32,46,109,32,111,114,
+32,46,100,0,1688945,1586063,12,8,1597071,12,8,1310721,2,19,26,1310721,
+2,7,26,2,26,1599321,12,10,3,6,10,4,8,1310721,2,7,
+26,2,25,40,3,36,1689109,16,1310721,2,11,26,2,1,6,1,
+10,28,34,63,38,1,10,28,1689111,14,1,1689213,16,1689205,14,111,
+110,108,121,32,116,104,101,32,102,105,114,115,116,32,49,50,
+32,112,97,114,97,109,101,116,101,114,115,32,99,97,110,32,
+98,101,32,116,97,103,103,101,100,0,1689119,1586063,12,8,1310721,2,
+67,26,1310721,2,7,26,2,26,1310721,2,11,26,2,10,3,6,
+10,4,8,1310721,2,7,26,2,25,40,1689339,16,1310721,2,9,26,
+1310721,2,9,26,2,1310721,2,11,26,2,1310721,2,7,26,2,1310721,
+2,7,26,2,26,48,26,10,3,6,10,4,8,1310721,2,7,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1310721,2,
+7,26,2,49,40,3,36,1689447,16,1689439,14,116,111,111,32,109,
+97,110,121,32,112,97,114,97,109,101,116,101,114,115,0,1689399,
+1586063,12,8,1584899,2,1598801,12,1,6,1,10,28,34,63,38,3,
+26,1689483,16,1689487,14,1688185,14,1584889,2,1599031,12,8,1584905,2,1598801,12,
+1689713,16,1584925,2,1598497,12,1,6,1,10,28,34,63,38,3,26,
+1689587,16,1310721,2,163,26,1635249,12,10,3,6,10,4,8,1310721,2,
+165,26,3,10,3,6,10,4,8,1584925,2,1598801,12,1689713,16,1584945,
+2,1598649,12,1,6,1,10,28,34,63,38,3,26,1689685,16,1689677,
+14,116,104,101,32,114,101,116,117,114,110,32,116,97,103,32,
+105,115,32,46,117,0,1689635,1586063,12,8,1597071,12,8,1310721,2,13,
+26,3,10,3,6,10,4,8,1310721,2,15,26,1310721,2,13,26,
+2,1310721,2,7,26,2,26,1310721,2,7,26,2,26,1310721,2,9,
+26,2,129,30,26,10,3,6,10,4,8,1442305,1310721,2,5,26,
+2,26,2,5,32,1689873,16,1442305,1310721,2,5,26,2,26,2,513,
+32,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1689875,14,1,1690035,16,1434113,1310721,2,5,26,
+2,26,2,1310721,2,15,26,2,28,1,6,1,10,28,34,63,
+38,1,10,28,1690031,16,1310721,2,3,26,2,1690023,14,100,111,101,
+115,110,39,116,32,109,97,116,99,104,32,105,116,115,32,101,
+97,114,108,105,101,114,32,100,101,99,108,97,114,97,116,105,
+111,110,0,1689947,1585849,12,8,1690323,14,1442305,1310721,2,5,26,2,26,
+2,9,32,1690137,16,1310721,2,9,26,2,1690079,16,3,1690111,14,1310721,
+2,13,26,2,1,6,1,10,28,34,63,38,1,10,28,1,
+6,1,10,28,34,63,38,1,10,28,1690139,14,1,1690323,16,1310721,
+2,3,26,2,1690315,14,119,97,115,32,99,97,108,108,101,100,
+32,98,101,102,111,114,101,32,105,116,115,32,116,97,103,115,
+32,119,101,114,101,32,100,101,99,108,97,114,101,100,59,32,
+112,117,116,32,97,32,112,114,111,116,111,116,121,112,101,32,
+97,98,111,118,101,32,116,104,101,32,102,105,114,115,116,32,
+99,97,108,108,0,1690157,1585849,12,8,1434113,1310721,2,5,26,2,26,
+1310721,2,15,26,2,10,3,6,10,4,8,1442305,1310721,2,5,26,
+2,26,1442305,1310721,2,5,26,2,26,2,5,34,1442305,1310721,2,5,
+26,2,26,2,513,32,28,10,3,6,10,4,8,1585009,2,1690481,
+16,1442305,1310721,2,5,26,2,26,1442305,1310721,2,5,26,2,26,2,
+257,34,10,3,6,10,4,8,1310721,2,165,26,2,1690851,16,1310721,
+2,163,26,2,1,6,1,10,28,34,63,38,3,26,1690553,16,
+1310721,2,163,26,1584975,2,10,3,6,10,4,8,1310721,2,167,26,
+1310721,2,163,26,2,1310721,2,7,26,2,1310721,2,115,26,1310721,2,
+15,26,2,1625329,12,10,3,6,10,4,8,1559041,1310721,2,5,26,
+2,26,2,1690711,16,1559041,1310721,2,5,26,2,26,2,1310721,2,167,
+26,2,28,1,6,1,10,28,34,63,38,1,10,28,1,6,
+1,10,28,34,63,38,1,10,28,1690713,14,1,1690815,16,1310721,2,
+3,26,2,1690807,14,100,111,101,115,110,39,116,32,109,97,116,
+99,104,32,105,116,115,32,101,97,114,108,105,101,114,32,100,
+101,99,108,97,114,97,116,105,111,110,0,1690731,1585849,12,8,1559041,
+1310721,2,5,26,2,26,1310721,2,167,26,2,10,3,6,10,4,
+8,1584901,2,1598801,12,1690893,16,1585009,1,10,3,6,10,4,8,1310721,
+2,5,26,2,1691783,14,1442305,1310721,2,5,26,2,26,2,3,32,
+1690973,16,1310721,2,3,26,2,1690965,14,105,115,32,100,101,102,105,
+110,101,100,32,116,119,105,99,101,0,1690931,1585849,12,8,1425921,1310721,
+2,5,26,2,26,1584837,2,10,3,6,10,4,8,1442305,1310721,2,
+5,26,2,26,1442305,1310721,2,5,26,2,26,2,3,34,10,3,
+6,10,4,8,1450497,1310721,2,5,26,2,26,2,1584837,2,1588737,12,
+8,1450497,1310721,2,5,26,2,26,1,10,3,6,10,4,8,1310721,
+2,2,1310721,2,13,26,2,1686347,12,8,1310721,2,165,26,2,1691163,
+16,1584885,1310721,2,163,26,2,10,3,6,10,4,8,1686679,12,8,
+1310721,2,17,26,1,10,3,6,10,4,8,1310721,2,17,26,2,
+1310721,2,7,26,2,40,1691633,16,1310721,2,11,26,1310721,2,19,26,
+1310721,2,17,26,2,26,2,1603891,12,10,3,6,10,4,8,1584851,
+1,6,2,1,6,3,26,5,6,4,10,8,8,1556993,1310721,2,
+11,26,2,26,1310721,2,115,26,1310721,2,17,26,2,26,2,10,
+3,6,10,4,8,1584853,2,1691419,16,1310721,2,67,26,1310721,2,17,
+26,2,26,2,3,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1691421,14,1,1691453,16,
+1469953,1310721,2,11,26,2,26,13,10,3,6,10,4,8,1584853,2,
+1691533,16,1310721,2,67,26,1310721,2,17,26,2,26,2,5,28,1,
+6,1,10,28,34,63,38,3,26,1,6,1,10,28,34,63,
+38,1,10,28,1691535,14,1,1691595,16,1469953,1310721,2,11,26,2,26,
+3,10,3,6,10,4,8,1474049,1310721,2,11,26,2,26,3,10,
+3,6,10,4,8,1310721,2,17,26,1,6,2,1,6,3,26,
+5,6,4,10,8,8,1691191,14,1310721,2,17,26,1310721,2,7,26,
+2,10,3,6,10,4,8,1310721,2,17,26,2,1691739,16,1310721,2,
+17,26,1,6,2,1,6,-1,26,5,6,4,10,8,8,1310721,
+2,17,26,2,1590069,12,8,5,1589235,12,8,1691663,14,1687087,12,8,
+1686903,12,8,1585009,1,10,3,6,10,4,8,1310721,2,5,26,2,
+1691783,14,1,1310721,2,169,26,1310721,4,18,1310721,2,13,28,1310721,4,
+1310721,2,1835009,40,1691831,16,1966081,1310721,4,1579069,12,1310721,2,4,1,1310721,
+2,9,26,4,1310721,2,2,1692107,16,1637945,12,8,1310721,2,9,26,
+1585011,2,10,3,6,10,4,8,1585013,2,1692001,16,1691993,14,116,97,
+103,115,32,103,111,32,111,110,32,108,111,99,97,108,115,32,
+97,110,100,32,112,97,114,97,109,101,116,101,114,115,44,32,
+110,111,116,32,103,108,111,98,97,108,115,0,1691901,1585679,12,8,
+1310721,2,9,26,2,1584983,2,28,1,6,1,10,28,34,63,38,
+3,26,1692103,16,1692095,14,97,32,118,97,114,105,97,98,108,101,
+32,99,97,110,39,116,32,98,101,32,118,111,105,100,0,1692045,
+1585679,12,8,1692113,14,1597071,12,8,3,1693065,16,1310721,2,3,26,1599321,
+12,10,3,6,10,4,8,1584895,2,1598801,12,1692441,16,1310721,2,7,
+26,1665803,12,10,3,6,10,4,8,1584897,2,1599031,12,8,1310721,2,
+11,26,1310721,2,3,26,2,7,1584837,2,1587311,12,10,3,6,10,
+4,8,1310721,2,9,26,2,1,6,1,10,28,34,63,38,3,
+26,1692287,16,1310721,2,9,26,1584975,2,10,3,6,10,4,8,1559041,
+1310721,2,11,26,2,26,1310721,2,9,26,2,1310721,2,7,26,2,
+1624809,12,10,3,6,10,4,8,1310721,2,7,26,1559041,1310721,2,11,
+26,2,26,2,1628577,12,10,3,6,10,4,8,1310721,2,7,26,
+2,1692437,16,1,1588955,12,8,1310721,2,7,26,1,6,2,1,6,
+-1,26,5,6,4,10,8,8,1692377,14,1693025,14,1310721,2,9,26,
+2,1692495,16,1310721,2,9,26,2,1629979,12,1,6,1,10,28,34,
+63,38,1,10,28,1692497,14,1,1692675,16,1310721,2,11,26,1310721,2,
+3,26,2,7,1584837,2,1587311,12,10,3,6,10,4,8,1559041,1310721,
+2,11,26,2,26,1310721,2,9,26,2,10,3,6,10,4,8,
+1310721,2,7,26,1310721,2,9,26,2,1628577,12,10,3,6,10,4,
+8,1310721,2,7,26,2,1692671,16,1,1588955,12,8,1310721,2,7,26,
+1,6,2,1,6,-1,26,5,6,4,10,8,8,1692611,14,1693025,
+14,1310721,2,5,26,1584837,2,10,3,6,10,4,8,1310721,2,11,
+26,1310721,2,3,26,2,5,1310721,2,5,26,2,1587311,12,10,3,
+6,10,4,8,1310721,2,9,26,2,1692795,16,1559041,1310721,2,11,26,
+2,26,1310721,2,9,26,2,10,3,6,10,4,8,1,1588955,12,
+8,1584903,2,1598801,12,1693025,16,1582577,2,7,28,1,6,1,10,28,
+34,63,38,3,26,1692993,16,1310721,2,5,26,2,1584839,2,26,1584837,
+2,10,3,6,10,4,8,1310721,2,7,26,1582579,2,10,3,6,
+10,4,8,1310721,2,7,26,2,2,1692975,16,1310721,2,7,26,2,
+2,1588955,12,8,1310721,2,7,26,1,6,2,1,6,3,26,5,
+6,4,10,8,8,1692903,14,1,1588955,12,8,1597071,12,8,1693025,14,
+1310721,2,5,26,2,1584839,2,26,1665803,12,10,3,6,10,4,8,
+1584899,2,1598801,12,1,6,1,10,28,34,63,38,3,26,1693061,16,
+1693065,14,1692113,14,1584901,2,1599031,12,8,1,1693083,14,1,1310721,2,13,
+26,1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1693131,16,
+1966081,1310721,4,1579069,12,1597071,12,8,3,1693231,16,1310721,2,1599321,12,10,
+3,6,10,4,8,1584903,2,1599031,12,8,1310721,2,2,9,1665803,12,
+1587311,12,8,1584899,2,1598801,12,1,6,1,10,28,34,63,38,3,
+26,1693227,16,1693231,14,1693137,14,1584901,2,1599031,12,8,1,1693249,14,1,
+1310721,2,3,26,1310721,4,18,1310721,2,43,28,1310721,4,1310721,2,1835009,
+40,1693297,16,1966081,1310721,4,1579069,12,1,1310721,2,3,26,4,3,1310721,
+2,5,26,4,1,1310721,2,13,26,4,1,1310721,2,15,26,4,
+1597071,12,8,1310721,2,1599321,12,10,3,6,10,4,8,1584887,2,1599031,
+12,8,1584889,2,1598497,12,1,6,1,10,28,34,63,38,3,26,
+1693655,16,3,1693655,16,1310721,2,3,26,2,17,28,1,6,1,10,
+28,34,63,38,3,26,1693545,16,1693537,14,97,110,32,101,110,104,
+97,110,99,101,109,101,110,116,32,116,97,107,101,115,32,97,
+116,32,109,111,115,116,32,56,32,105,110,112,117,116,115,0,
+1693461,1586063,12,8,1310721,2,27,26,1310721,2,3,26,2,26,1599321,12,
+10,3,6,10,4,8,1310721,2,3,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1584899,2,1598801,12,1,6,1,10,28,
+34,63,38,3,26,1693651,16,1693655,14,1693413,14,1584889,2,1599031,12,8,
+1584905,2,1598801,12,1693897,16,1582577,2,3,28,1,6,1,10,28,34,
+63,38,1,10,28,1693717,16,3,1693747,14,1582579,2,1,40,1,6,
+1,10,28,34,63,38,1,10,28,1693757,16,3,1693789,14,1582579,2,
+17,10,40,1,6,1,10,28,34,63,38,1,10,28,1693867,16,
+1693859,14,101,120,112,101,99,116,101,100,32,116,104,101,32,110,
+117,109,98,101,114,32,111,102,32,111,117,116,112,117,116,115,
+0,1693797,1586063,12,8,1310721,2,5,26,1582579,2,10,3,6,10,4,
+8,1597071,12,8,1310721,2,7,26,1584837,2,10,3,6,10,4,8,
+1310721,2,17,26,1,10,3,6,10,4,8,1310721,2,17,26,2,
+15,40,1694007,16,1,1588955,12,8,1310721,2,17,26,1,6,2,1,
+6,3,26,5,6,4,10,8,8,1693943,14,1310721,2,9,26,1584837,
+2,10,3,6,10,4,8,1310721,2,17,26,1,10,3,6,10,
+4,8,1310721,2,17,26,2,1310721,2,3,26,2,40,1694125,16,1,
+1588955,12,8,1310721,2,17,26,1,6,2,1,6,3,26,5,6,
+4,10,8,8,1694053,14,1310721,2,17,26,1,10,3,6,10,4,
+8,1310721,2,17,26,2,1310721,2,3,26,2,40,1694377,16,1310721,2,
+9,26,2,1310721,2,17,26,2,26,1584839,2,26,1584837,2,10,3,
+6,10,4,8,1310721,2,19,26,1310721,2,27,26,1310721,2,17,26,
+2,26,2,10,3,6,10,4,8,1310721,2,19,26,2,2,1694331,
+16,1310721,2,19,26,2,2,1588955,12,8,1310721,2,19,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1694259,14,1,1588955,12,
+8,1310721,2,17,26,1,6,2,1,6,3,26,5,6,4,10,
+8,8,1694147,14,1584967,2,1598801,12,1694673,16,1310721,2,11,26,1584837,2,
+10,3,6,10,4,8,1582577,2,7,28,1,6,1,10,28,34,
+63,38,1,10,28,1694523,16,1694515,14,101,120,112,101,99,116,101,
+100,32,116,104,101,32,114,101,99,105,112,101,32,97,115,32,
+97,32,115,116,114,105,110,103,0,1694451,1586063,12,8,1582577,2,7,
+28,1,6,1,10,28,34,63,38,3,26,1694661,16,1310721,2,19,
+26,1582579,2,10,3,6,10,4,8,1310721,2,19,26,2,2,1694651,
+16,1310721,2,19,26,2,2,1588955,12,8,1310721,2,19,26,1,6,
+2,1,6,3,26,5,6,4,10,8,8,1694579,14,1597071,12,8,
+1694523,14,1,1588955,12,8,1694839,14,1584969,2,1598801,12,1694785,16,1310721,2,
+11,26,1584837,2,10,3,6,10,4,8,1676857,12,8,19,1589235,12,
+8,1310721,2,13,26,1584837,2,1310721,2,11,26,2,28,10,3,6,
+10,4,8,1310721,2,15,26,3,10,3,6,10,4,8,1694839,14,
+1694831,14,101,120,112,101,99,116,101,100,32,109,105,99,114,111,
+32,111,114,32,118,109,0,1694789,1586063,12,8,1310721,2,23,26,1582503,
+2,10,3,6,10,4,8,1310721,2,23,26,2,1025,40,3,36,
+1694969,16,1694961,14,97,108,108,32,53,49,50,32,101,110,104,97,
+110,99,101,109,101,110,116,32,115,108,111,116,115,32,97,114,
+101,32,116,97,107,101,110,0,1694889,1585585,12,8,1582503,1,6,2,
+1,6,3,26,5,6,4,10,8,8,1310721,2,19,26,1310721,2,
+7,26,2,1584839,2,26,10,3,6,10,4,8,1310721,2,19,26,
+2,1,26,1310721,2,23,26,2,10,3,6,10,4,8,1310721,2,
+19,26,2,3,26,1310721,2,15,26,2,10,3,6,10,4,8,
+1310721,2,19,26,2,5,26,1310721,2,3,26,2,10,3,6,10,
+4,8,1310721,2,19,26,2,7,26,1310721,2,5,26,2,10,3,
+6,10,4,8,1310721,2,19,26,2,9,26,1310721,2,11,26,2,
+10,3,6,10,4,8,1310721,2,19,26,2,11,26,1310721,2,13,
+26,2,10,3,6,10,4,8,1310721,2,19,26,2,13,26,1310721,
+2,9,26,2,10,3,6,10,4,8,1310721,2,21,26,1310721,2,
+2,13,1310721,2,23,26,2,1587311,12,10,3,6,10,4,8,1434113,
+1310721,2,21,26,2,26,1310721,2,3,26,2,1310721,2,5,26,2,
+33,30,26,1310721,2,7,26,2,513,30,26,10,3,6,10,4,
+8,1584933,2,1598801,12,1695527,16,1310721,2,25,26,1582579,2,1587809,12,10,
+3,6,10,4,8,1310721,2,25,26,2,1,40,1695481,16,1310721,2,
+25,26,1582579,2,1589617,12,10,3,6,10,4,8,1597071,12,8,1450497,
+1310721,2,21,26,2,26,1310721,2,25,26,2,3,26,10,3,6,
+10,4,8,1584901,2,1599031,12,8,1584839,2,1,6,1,10,28,34,
+63,38,3,26,1695847,16,1310721,2,25,26,1310721,2,7,26,2,1572879,
+12,10,3,6,10,4,8,1310721,2,25,26,2,1,40,1695847,16,
+1450497,1310721,2,21,26,2,26,2,1,6,1,10,28,34,63,38,
+3,26,1695801,16,1310721,2,2,1695793,14,116,104,101,32,101,110,104,
+97,110,99,101,109,101,110,116,32,100,105,100,110,39,116,32,
+105,110,115,116,97,108,108,32,40,115,101,101,32,105,110,115,
+116,97,108,108,39,115,32,99,111,100,101,115,32,105,110,32,
+99,111,114,101,46,99,41,0,1695667,1585849,12,8,1442305,1310721,2,21,
+26,2,26,1442305,1310721,2,21,26,2,26,2,129,34,10,3,6,
+10,4,8,1,1695855,14,1,1310721,2,43,26,1310721,4,18,1310721,2,
+3,28,1310721,4,1310721,2,1835009,40,1695903,16,1966081,1310721,4,1579069,12,1,
+1310721,2,4,1582577,2,1,28,1,6,1,10,28,34,63,38,1,
+10,28,1696731,16,1584891,2,1598497,12,1695991,16,1310721,2,1,6,2,1,
+6,3,26,5,6,4,10,8,8,1696721,14,1584893,2,1598497,12,1696069,
+16,1310721,2,1,6,2,1,6,-1,26,5,6,4,10,8,8,
+1310721,2,2,1,40,1696065,16,1310721,2,1,10,3,6,10,4,8,
+1696721,14,1310721,2,2,1,6,1,10,28,34,63,38,3,26,1696153,
+16,1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1696155,14,1,1696711,16,1582579,
+2,1584927,2,28,1,6,1,10,28,34,63,38,3,26,1696199,16,
+3,1696251,14,1582579,2,1584929,2,28,1,6,1,10,28,34,63,38,
+3,26,1,6,1,10,28,34,63,38,1,10,28,1696261,16,3,
+1696313,14,1582579,2,1584931,2,28,1,6,1,10,28,34,63,38,3,
+26,1,6,1,10,28,34,63,38,1,10,28,1696323,16,3,1696375,
+14,1582579,2,1585031,2,28,1,6,1,10,28,34,63,38,3,26,
+1,6,1,10,28,34,63,38,1,10,28,1696385,16,3,1696437,14,
+1582579,2,1585033,2,28,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1696447,16,3,1696499,14,1582579,
+2,1584965,2,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1696509,16,3,1696561,14,1582579,2,
+1585035,2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1696571,16,3,1696623,14,1582579,2,1584937,
+2,28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,
+28,34,63,38,1,10,28,1696633,16,3,1696685,14,1582579,2,1584939,2,
+28,1,6,1,10,28,34,63,38,3,26,1,6,1,10,28,
+34,63,38,1,10,28,1,6,1,10,28,34,63,38,1,10,
+28,1696713,14,1,1696721,16,1696731,14,1597071,12,8,1695911,14,1585091,1,10,
+3,6,10,4,8,1,1696755,14,1,1310721,2,3,26,1310721,4,18,
+1310721,2,9,28,1310721,4,1310721,2,1835009,40,1696803,16,1966081,1310721,4,1579069,
+12,3,1310721,2,4,1,1310721,2,3,26,4,1585091,2,1696839,16,1695869,
+12,1697853,14,1584937,2,1598649,12,1696909,16,1597071,12,8,1584901,2,1598801,12,
+1696891,16,1582575,1,10,3,6,10,4,8,1,1697853,14,1310721,2,1,
+10,3,6,10,4,8,1584939,2,1598649,12,1696949,16,1597071,12,8,1310721,
+2,3,26,3,10,3,6,10,4,8,1584927,2,1598649,12,1697235,16,
+1310721,2,5,26,1310721,2,2,1687483,12,10,3,6,10,4,8,1310721,
+2,3,26,2,1697229,16,1584839,2,1697131,16,1697123,14,112,97,114,115,
+101,32,119,111,114,100,115,32,99,97,110,39,116,32,98,101,
+32,100,101,102,105,110,101,100,32,119,104,105,108,101,32,98,
+117,105,108,100,105,110,103,32,97,110,32,105,109,97,103,101,
+0,1697017,1585679,12,8,1310721,2,7,26,1409537,1310721,2,5,26,2,26,
+2,11,1425921,1310721,2,5,26,2,26,2,1587311,12,10,3,6,10,
+4,8,1442305,1310721,2,7,26,2,26,3,17,34,33,34,65,34,
+10,3,6,10,4,8,1,1697853,14,1310721,2,2,1,6,1,10,
+28,34,63,38,3,26,1697271,16,3,1697303,14,1310721,2,3,26,2,
+1,6,1,10,28,34,63,38,1,10,28,1697349,16,1697335,14,101,
+120,112,101,99,116,101,100,32,102,110,0,1697311,1586063,12,8,1,
+1697853,14,1584929,2,1598649,12,1697371,16,1,1691797,12,1697853,14,1585031,2,1598649,
+12,1697395,16,1638319,12,8,1,1697853,14,1585033,2,1598649,12,1697415,16,1640225,
+12,1697853,14,1585035,2,1598649,12,1697435,16,1640345,12,1697853,14,1584965,2,1598649,
+12,1697455,16,1693263,12,1697853,14,1584931,2,1598649,12,1697475,16,1693097,12,1697853,
+14,1582577,2,5,28,1,6,1,10,28,34,63,38,3,26,1697705,
+16,1310721,2,5,26,1582579,2,1587809,12,10,3,6,10,4,8,1310721,
+2,5,26,2,1,40,3,36,1697623,16,1417729,1310721,2,5,26,2,
+26,2,11,28,1,6,1,10,28,34,63,38,3,26,1,6,
+1,10,28,34,63,38,1,10,28,1697625,14,1,1697675,16,1442305,1310721,
+2,5,26,2,26,2,65,32,1,6,1,10,28,34,63,38,
+1,10,28,1697677,14,1,1697705,16,1310721,2,5,26,2,1,1647877,12,
+8,1,1697853,14,1637143,12,1697723,16,3,1691797,12,1697853,14,1697837,14,101,
+120,112,101,99,116,101,100,32,102,110,44,32,108,101,116,44,
+32,99,111,110,115,116,44,32,115,116,114,117,99,116,44,32,
+116,121,112,101,32,111,114,32,97,32,100,101,99,108,97,114,
+97,116,105,111,110,0,1697727,1586063,12,8,1,1697853,14,1,1310721,2,
+9,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,40,1697901,
+16,1966081,1310721,4,1579069,12,1582577,2,1,28,1,6,1,10,28,34,
+63,38,1,10,28,1697945,16,1696769,12,8,1697901,14,1,1697953,14,1,
+1310721,2,1,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,2,1835009,
+40,1698001,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,1310721,2,
+3,26,4,1585091,1,10,3,6,10,4,8,1310721,2,3,26,2,
+1582507,2,40,1698371,16,1417729,1310721,2,3,26,2,26,2,3,28,1,
+6,1,10,28,34,63,38,3,26,1698169,16,1442305,1310721,2,3,26,
+2,26,2,3,32,1,6,1,10,28,34,63,38,3,26,1,
+6,1,10,28,34,63,38,1,10,28,1698171,14,1,1698217,16,1450497,
+1310721,2,3,26,2,26,2,1,6,1,10,28,34,63,38,1,
+10,28,1698219,14,1,1698333,16,1582583,1425921,1310721,2,3,26,2,26,2,
+10,3,6,10,4,8,1409537,1310721,2,3,26,2,26,2,1698325,14,
+105,115,32,117,115,101,100,32,98,117,116,32,110,101,118,101,
+114,32,100,101,102,105,110,101,100,0,1698273,1585849,12,8,1310721,2,
+3,26,1,6,2,1,6,3,26,5,6,4,10,8,8,1698039,
+14,1585089,2,1698385,16,1585397,12,8,1,1698393,14,1,1310721,2,5,26,
+1310721,4,18,1310721,2,11,28,1310721,4,1310721,2,1835009,40,1698441,16,1966081,
+1310721,4,1579069,12,1310721,2,3,26,4,1310721,2,4,3,1,10,28,
+1310721,2,5,26,4,1,1310721,2,7,26,4,1582507,2,1310721,2,9,
+26,4,1684867,12,8,1584865,2,1698547,16,1310721,2,5,26,1589535,12,10,
+3,6,10,4,8,15,1589235,12,8,1310721,2,3,26,2,1698575,16,
+3,1310721,2,2,1684251,12,8,3,1310721,2,2,1,1,1590943,12,8,
+1597071,12,8,1310721,2,3,26,2,1698623,16,1697867,12,8,1698777,14,1310721,
+2,7,26,1584837,2,10,3,6,10,4,8,3,1,1686347,12,8,
+1686679,12,8,1582577,2,1,28,1,6,1,10,28,34,63,38,1,
+10,28,1698707,16,1666771,12,8,1698663,14,1584847,2,1606191,12,8,1584853,2,
+1698755,16,1584857,2,1,6,1,10,28,34,63,38,1,10,28,1698757,
+14,1,1698771,16,3,3,1605463,12,8,1686903,12,8,1592371,12,8,1310721,
+2,9,26,2,1697967,12,8,1310721,2,5,26,2,1,40,3,36,
+1698841,16,1310721,2,5,26,2,1584837,2,1589317,12,8,1584837,2,1584843,2,
+10,40,1698875,16,1584843,1584837,2,10,3,6,10,4,8,1685643,12,8,
+1310721,2,7,26,2,1698897,14,1,1310721,2,11,26,1310721,4,18,1310721,
+2,3,28,1310721,4,1310721,2,1835009,40,1698945,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,1,1698407,12,1698969,14,1,1310721,2,3,26,
+1310721,4,18,1310721,2,3,28,1310721,4,1310721,2,1835009,40,1699017,16,1966081,
+1310721,4,1579069,12,1310721,2,4,1310721,2,2,3,1698407,12,8,1,1699045,
+14,1,1310721,2,3,26,1310721,4,18,1310721,2,5,28,1310721,4,1310721,
+2,1835009,40,1699093,16,1966081,1310721,4,1579069,12,1310721,2,4,1310721,2,2,
+1,1698407,12,1310721,2,3,26,4,1310721,2,3,26,2,1,6,12,
+10,8,1699147,14,1,1310721,2,5,26,1310721,4,18,1310721,2,7,28,
+1310721,4,1310721,2,1835009,40,1699195,16,1966081,1310721,4,1579069,12,1310721,2,4,
+1310721,2,2,1680951,12,1310721,2,3,26,4,1310721,2,3,26,2,1699059,
+12,1310721,2,5,26,4,1310721,2,3,26,2,1580623,12,8,1310721,2,
+5,26,2,1699277,14,1,1310721,2,7,26,1310721,4,18,1310721,2,7,
+28,1310721,4,1310721,2,1835009,40,1699325,16,1966081,1310721,4,1579069,12,1310721,2,
+4,1310721,2,2,1310721,2,3,26,4,1310721,2,3,26,2,1582507,2,
+40,1699745,16,1417729,1310721,2,3,26,2,26,2,3,40,3,36,1699447,
+16,1417729,1310721,2,3,26,2,26,2,9,10,40,3,36,1,6,
+1,10,28,34,63,38,1,10,28,1699449,14,1,1699459,16,3,1699521,
+14,1417729,1310721,2,3,26,2,26,2,13,28,1,6,1,10,28,
+34,63,38,3,26,1,6,1,10,28,34,63,38,1,10,28,
+1699707,16,1417729,1310721,2,3,26,2,26,2,1588955,12,8,1425921,1310721,2,
+3,26,2,26,2,1588955,12,8,1434113,1310721,2,3,26,2,26,2,
+1588955,12,8,1310721,2,5,26,1409537,1310721,2,3,26,2,26,2,10,
+3,6,10,4,8,1310721,2,5,26,2,2,1699699,16,1310721,2,5,
+26,2,2,1588955,12,8,1310721,2,5,26,1,6,2,1,6,3,
+26,5,6,4,10,8,8,1699627,14,1,1588955,12,8,1310721,2,3,
+26,1,6,2,1,6,3,26,5,6,4,10,8,8,1699347,14,
+1,1588955,12,8,1,1699761,14,1,1310721,2,7,26,1310721,4,18,1310721,
+2,7,28,1310721,4,1310721,2,1835009,40,1699809,16,1966081,1310721,4,1579069,12,
+1310721,2,4,1310721,2,2,2,1700157,16,1310721,2,5,26,1310721,2,2,
+7,26,1586793,12,10,3,6,10,4,8,1310721,2,3,26,1310721,2,
+5,26,2,1310721,2,2,1,26,2,1310721,2,2,3,26,2,1587311,
+12,10,3,6,10,4,8,1434113,1310721,2,3,26,2,26,1310721,2,
+2,5,26,2,10,3,6,10,4,8,1442305,1310721,2,3,26,2,
+26,3,5,34,10,3,6,10,4,8,1310721,2,2,1,26,2,
+13,28,1,6,1,10,28,34,63,38,3,26,1700107,16,1310721,2,
+2,3,26,2,1582503,2,40,3,36,1700085,16,1582503,1310721,2,2,3,
+26,2,3,26,10,3,6,10,4,8,1310721,2,2,5,26,2,
+17,38,1572879,12,8,1310721,2,1310721,2,2,7,26,1310721,2,2,7,
+26,1573885,12,26,3,26,10,3,6,10,4,8,1699815,14,1,1700165,
+14,1,1310721,2,7,26,1310721,4,18,1310721,2,21,28,1310721,4,1310721,
+2,1835009,40,1700213,16,1966081,1310721,4,1579069,12,1310721,2,3,26,4,1310721,
+2,4,1584837,2,1310721,2,5,26,4,1584839,2,1310721,2,7,26,4,
+1584841,2,1310721,2,9,26,4,1582509,2,1310721,2,11,26,4,1582511,2,
+1310721,2,13,26,4,1582507,2,1310721,2,15,26,4,1582503,2,1310721,2,
+17,26,4,1582509,1582507,2,10,3,6,10,4,8,1582511,1582507,2,10,
+3,6,10,4,8,1582503,1,10,3,6,10,4,8,1584837,1310721,2,
+2,10,3,6,10,4,8,1584839,1310721,2,3,26,2,1310721,2,2,
+28,10,3,6,10,4,8,1584841,1310721,2,2,393217,26,10,3,6,
+10,4,8,1966081,1589149,12,8,1310721,1589149,12,8,5,1589235,12,8,1584955,
+2,1589617,12,1589741,12,8,15,1589235,12,8,1,1588955,12,8,1,1588955,
+12,8,1684729,12,8,1310721,2,3,26,2,11,26,1584837,2,10,3,
+6,10,4,8,1582509,2,1699291,12,8,1310721,2,3,26,2,13,26,
+1584837,2,10,3,6,10,4,8,1310721,2,19,26,1584837,2,1310721,2,
+2,28,10,3,6,10,4,8,1310721,2,15,26,2,1588157,12,8,
+1582509,1310721,2,11,26,2,10,3,6,10,4,8,1582511,1310721,2,13,
+26,2,10,3,6,10,4,8,1584837,1310721,2,5,26,2,10,3,
+6,10,4,8,1584839,1310721,2,7,26,2,10,3,6,10,4,8,
+1584841,1310721,2,9,26,2,10,3,6,10,4,8,1582503,1310721,2,17,
+26,2,10,3,6,10,4,8,1310721,2,19,26,2,1700801,14,1,
+1310721,2,21,26,1310721,4,18,1310721,2,1,28,1310721,4,1310721,2,1835009,
+40,1700849,16,1966081,1310721,4,1579069,12,1,1584843,2,1581139,12,8,1584839,2,
+1,6,1,10,28,34,63,38,3,26,1700927,16,1584837,2,1584843,2,
+10,40,1,6,1,10,28,34,63,38,1,10,28,1700929,14,1,
+1700947,16,1584843,2,1584837,2,1581139,12,8,1572865,1572865,13,26,2,1581139,12,
+8,1540609,1540609,2049,26,1581139,12,8,1310721,2,1966081,1581139,12,8,2064385,2097121,
+1581139,12,8,1,1701007,14,1,1310721,2,1,26,1310721,4,18,1310721,2,
+1,28,1310721,4,1310721,2,1835009,40,1701055,16,1966081,1310721,4,1579069,12,1582505,
+1327617,10,3,6,10,4,8,1311233,1,16385,1574549,12,8,1582507,1,10,
+3,6,10,4,8,1582513,1,10,3,6,10,4,8,1582515,1,10,
+3,6,10,4,8,1582517,1,10,3,6,10,4,8,1582519,1,10,
+3,6,10,4,8,1582521,1,10,3,6,10,4,8,1582523,1,10,
+3,6,10,4,8,1582525,1,10,3,6,10,4,8,1584867,1,10,
+3,6,10,4,8,1584871,1,10,3,6,10,4,8,1584873,1,10,
+3,6,10,4,8,1584845,1,10,3,6,10,4,8,1584847,1,10,
+3,6,10,4,8,1584887,1701301,14,40,0,1701297,1586793,12,10,3,6,
+10,4,8,1584889,1701329,14,41,0,1701325,1586793,12,10,3,6,10,4,
+8,1584891,1701357,14,123,0,1701353,1586793,12,10,3,6,10,4,8,1584893,
+1701385,14,125,0,1701381,1586793,12,10,3,6,10,4,8,1584895,1701413,14,
+91,0,1701409,1586793,12,10,3,6,10,4,8,1584897,1701441,14,93,0,
+1701437,1586793,12,10,3,6,10,4,8,1584899,1701469,14,44,0,1701465,1586793,
+12,10,3,6,10,4,8,1584901,1701497,14,59,0,1701493,1586793,12,10,
+3,6,10,4,8,1584903,1701525,14,61,0,1701521,1586793,12,10,3,6,
+10,4,8,1584905,1701555,14,45,62,0,1701549,1586793,12,10,3,6,10,
+4,8,1584907,1701585,14,43,43,0,1701579,1586793,12,10,3,6,10,4,
+8,1584909,1701615,14,45,45,0,1701609,1586793,12,10,3,6,10,4,8,
+1584911,1701643,14,42,0,1701639,1586793,12,10,3,6,10,4,8,1584913,1701671,
+14,38,0,1701667,1586793,12,10,3,6,10,4,8,1584915,1701699,14,58,
+0,1701695,1586793,12,10,3,6,10,4,8,1584917,1701727,14,35,0,1701723,
+1586793,12,10,3,6,10,4,8,1584919,1701755,14,45,0,1701751,1586793,12,
+10,3,6,10,4,8,1584925,1701783,14,46,0,1701779,1586793,12,10,3,
+6,10,4,8,1584947,1701811,14,63,0,1701807,1586793,12,10,3,6,10,
+4,8,1584949,1701845,14,99,97,115,101,0,1701835,1586793,12,10,3,6,
+10,4,8,1584951,1701885,14,100,101,102,97,117,108,116,0,1701869,1586793,
+12,10,3,6,10,4,8,1584921,1701915,14,38,38,0,1701909,1586793,12,
+10,3,6,10,4,8,1584923,1701945,14,124,124,0,1701939,1586793,12,10,
+3,6,10,4,8,1584927,1701975,14,102,110,0,1701969,1586793,12,10,3,
+6,10,4,8,1584929,1702007,14,108,101,116,0,1701999,1586793,12,10,3,
+6,10,4,8,1584931,1702043,14,99,111,110,115,116,0,1702031,1586793,12,
+10,3,6,10,4,8,1584933,1702077,14,101,108,115,101,0,1702067,1586793,
+12,10,3,6,10,4,8,1584935,1702107,14,97,115,0,1702101,1586793,12,
+10,3,6,10,4,8,1584937,1702151,14,117,110,99,104,101,99,107,
+101,100,0,1702131,1586793,12,10,3,6,10,4,8,1584939,1702195,14,105,
+109,109,101,100,105,97,116,101,0,1702175,1586793,12,10,3,6,10,
+4,8,1584941,1702223,14,109,0,1702219,1586793,12,10,3,6,10,4,8,
+1584943,1702251,14,100,0,1702247,1586793,12,10,3,6,10,4,8,1584945,1702279,
+14,117,0,1702275,1586793,12,10,3,6,10,4,8,1584955,1702315,14,115,
+116,97,114,116,0,1702303,1586793,12,10,3,6,10,4,8,1584957,1702349,
+14,109,97,105,110,0,1702339,1586793,12,10,3,6,10,4,8,1584959,
+1702383,14,102,114,101,101,0,1702373,1586793,12,10,3,6,10,4,8,
+1584961,1702415,14,111,119,110,0,1702407,1586793,12,10,3,6,10,4,8,
+1584963,1702449,14,113,110,101,119,0,1702439,1586793,12,10,3,6,10,4,
+8,1584953,1702503,14,102,114,97,109,101,95,111,118,101,114,102,108,
+111,119,0,1702473,1586793,12,10,3,6,10,4,8,1584965,1702543,14,101,
+110,104,97,110,99,101,0,1702527,1586793,12,10,3,6,10,4,8,
+1584967,1702579,14,109,105,99,114,111,0,1702567,1586793,12,10,3,6,10,
+4,8,1584969,1702609,14,118,109,0,1702603,1586793,12,10,3,6,10,4,
+8,1,1702635,14,1,1310721,2,1,26,1310721,4,18,1310721,2,1,28,
+1310721,4,1310721,2,1835009,40,1702683,16,1966081,1310721,4,1579069,12,1702691,14,33,
+0,1702687,1702739,14,48,32,36,32,48,32,126,32,45,32,124,32,
+51,49,32,62,32,49,32,43,0,1702697,1603187,12,8,1702757,14,33,
+33,0,1702751,1702809,14,48,32,36,32,48,32,126,32,45,32,124,
+32,51,49,32,62,32,48,32,126,32,45,0,1702763,1603187,12,8,
+1702825,14,126,0,1702821,1702841,14,45,49,32,94,0,1702831,1603187,12,8,
+1702857,14,45,0,1702853,1702875,14,48,32,126,32,45,0,1702863,1603187,12,
+8,1702891,14,42,0,1702887,21,1702903,14,42,0,1702899,1602147,12,8,1702919,
+14,47,0,1702915,21,1702937,14,105,100,105,118,0,1702927,1602147,12,8,
+1702953,14,37,0,1702949,21,1702971,14,105,109,111,100,0,1702961,1602147,12,
+8,1702987,14,43,0,1702983,19,1702999,14,43,0,1702995,1602147,12,8,1703015,
+14,45,0,1703011,19,1703027,14,45,0,1703023,1602147,12,8,1703045,14,60,
+60,0,1703039,17,1703063,14,105,115,104,108,0,1703053,1602147,12,8,1703081,
+14,62,62,0,1703075,17,1703093,14,62,0,1703089,1602147,12,8,1703109,14,
+60,0,1703105,15,1703121,14,60,0,1703117,1602147,12,8,1703137,14,62,0,
+1703133,15,1703153,14,126,32,60,0,1703145,1602147,12,8,1703171,14,60,61,
+0,1703165,15,1703195,14,126,32,60,32,49,32,94,0,1703179,1602147,12,
+8,1703213,14,62,61,0,1703207,15,1703233,14,60,32,49,32,94,0,
+1703221,1602147,12,8,1703251,14,61,61,0,1703245,13,1703305,14,45,32,48,
+32,36,32,48,32,126,32,45,32,124,32,51,49,32,62,32,
+49,32,43,0,1703259,1602147,12,8,1703323,14,33,61,0,1703317,13,1703381,
+14,45,32,48,32,36,32,48,32,126,32,45,32,124,32,51,
+49,32,62,32,48,32,126,32,45,0,1703331,1602147,12,8,1703397,14,
+38,0,1703393,11,1703409,14,38,0,1703405,1602147,12,8,1703425,14,94,0,
+1703421,9,1703437,14,94,0,1703433,1602147,12,8,1703453,14,124,0,1703449,7,
+1703465,14,124,0,1703461,1602147,12,8,1703483,14,38,38,0,1703477,3,1,
+10,28,1,1602147,12,8,1703511,14,124,124,0,1703505,5,1,10,28,
+1,1602147,12,8,1584903,2,1601319,12,8,1584905,2,1601319,12,8,1584907,2,
+1601319,12,8,1584909,2,1601319,12,8,1703581,14,108,101,116,0,1703573,1668993,
+17,1603521,12,8,1703603,14,105,102,0,1703597,1669065,17,1603521,12,8,1703631,
+14,119,104,105,108,101,0,1703619,1671631,17,1603521,12,8,1703655,14,102,
+111,114,0,1703647,1672243,17,1603521,12,8,1703685,14,115,119,105,116,99,
+104,0,1703671,1674813,17,1603521,12,8,1703713,14,98,114,101,97,107,0,
+1703701,1673347,17,1603521,12,8,1703747,14,99,111,110,116,105,110,117,101,
+0,1703729,1673773,17,1603521,12,8,1703777,14,114,101,116,117,114,110,0,
+1703763,1676117,17,1603521,12,8,1703813,14,117,110,99,104,101,99,107,101,
+100,0,1703793,1676737,17,1603521,12,8,1703837,14,97,115,109,0,1703829,1679427,
+17,33,34,1603521,12,8,1703869,14,113,117,111,116,101,0,1703857,1680677,
+33,1603521,12,8,1703899,14,115,105,122,101,111,102,0,1703885,1641141,33,
+1603521,12,8,1703929,14,116,121,112,101,111,102,0,1703915,1641257,33,1603521,
+12,8,1,1703949,14,1,1310721,2,1,26,1310721,4,18,1310721,2,5,
+28,1310721,4,1310721,2,1835009,40,1703997,16,1966081,1310721,4,1579069,12,1577079,12,
+8,1701021,12,8,1572865,11,26,2,1699775,12,8,1702649,12,8,1641369,12,
+8,1584837,1,10,3,6,10,4,8,1584839,1,10,3,6,10,4,
+8,1584841,524289,10,3,6,10,4,8,1584843,1,10,3,6,10,4,
+8,1582509,1582507,2,10,3,6,10,4,8,1582511,1,10,3,6,10,
+4,8,1684729,12,8,1584837,2,1584843,2,10,40,1704173,16,1584843,1584837,2,
+10,3,6,10,4,8,1310721,2,1584957,2,1587809,12,10,3,6,10,
+4,8,1310721,2,2,1,40,3,36,1704277,16,1417729,1310721,2,2,26,
+2,3,28,1,6,1,10,28,34,63,38,3,26,1,6,1,
+10,28,34,63,38,1,10,28,1704279,14,1,1704325,16,1442305,1310721,2,
+2,26,2,3,32,1,6,1,10,28,34,63,38,1,10,28,
+1704327,14,1,1704385,16,1310721,2,3,26,1425921,1310721,2,2,26,2,10,
+3,6,10,4,8,1310721,2,3,26,2,1,6,12,10,8,8,
+1573283,12,8,1,1704399,14,1,1310721,2,5,26,1310721,4,18,1,851981,
+0,115,116,97,114,116,0,1,786439,2,105,110,115,116,97,108,
+108,0,1,786550,2,112,117,116,99,0,1,786585,0,103,101,116,
+99,0,1,786613,0,101,111,102,0,1,786641,0,104,97,108,116,
+0,1,786670,2,112,117,116,115,0,1,786751,2,112,117,116,110,
+0,1,786942,2,115,116,114,108,101,110,0,1,787014,4,115,116,
+114,101,113,0,1,787168,6,119,99,111,112,121,0,1,787274,6,
+119,102,105,108,108,0,1,787406,4,122,117,100,105,118,0,1,
+787637,4,122,100,105,118,0,1,787825,4,122,109,111,100,0,1,
+787920,4,122,115,104,108,0,1,788005,2,116,111,112,115,105,122,
+101,0,1,788181,4,102,112,117,115,104,0,1,788305,4,102,117,
+110,108,105,110,107,0,1,788418,4,109,107,98,108,111,99,107,
+0,1,788539,0,104,101,97,112,95,105,110,105,116,0,1,788770,
+2,98,97,108,108,111,99,0,1,789007,2,98,102,114,101,101,
+0,1,789405,2,105,115,111,98,106,0,1,789534,0,102,114,97,
+109,101,95,111,118,101,114,102,108,111,119,0,1,789597,0,111,
+111,109,0,1,789658,5,110,101,119,95,116,0,1,789961,3,110,
+101,119,0,1,789997,2,111,115,105,122,101,0,1,790058,2,116,
+121,112,101,111,102,95,111,98,106,0,1,790117,2,114,101,108,
+101,97,115,101,0,1,790311,130,102,114,101,101,0,1,790355,4,
+111,119,110,0,1,790423,2,109,97,114,107,0,1,790569,4,109,
+97,114,107,114,97,110,103,101,0,1,790640,0,100,114,97,105,
+110,0,1,850407,0,103,99,95,114,111,111,116,115,0,1,790722,
+0,103,99,0,1,791040,0,108,105,118,101,95,111,98,106,101,
+99,116,115,0,1,791136,0,108,97,114,103,101,115,116,95,102,
+114,101,101,0,1,792546,0,101,114,114,97,116,0,1,792618,0,
+101,114,114,101,110,100,0,1,792698,0,103,105,118,101,117,112,
+0,1,792792,2,102,97,116,97,108,0,1,792839,2,115,101,114,
+114,0,1,792924,4,115,101,114,114,110,0,1,793031,2,100,105,
+101,0,1,793098,4,100,105,101,110,0,1,793175,2,99,101,114,
+114,0,1,793234,4,99,101,114,114,110,0,1,793306,2,104,97,
+115,104,115,0,1,793396,2,105,110,116,101,114,110,0,1,793655,
+6,97,100,100,115,121,109,0,1,793904,2,108,111,111,107,117,
+112,0,1,794078,2,112,111,112,115,121,109,115,0,1,794155,2,
+108,111,111,107,117,112,115,0,1,794192,4,102,105,120,110,101,
+119,0,1,794368,4,102,105,120,97,108,108,0,1,794477,2,101,
+109,105,116,0,1,794574,2,108,105,116,0,1,794617,2,111,112,
+0,1,794658,4,115,101,116,108,105,116,0,1,794726,2,106,109,
+112,0,1,794767,0,104,111,108,101,0,1,794808,2,102,119,100,
+102,110,0,1,794870,2,102,110,114,101,102,0,1,794957,2,99,
+97,108,108,110,97,109,101,0,1,795034,2,108,97,100,100,114,
+0,1,795088,2,115,116,114,108,105,116,0,1,795194,0,110,101,
+120,116,99,104,0,1,795471,8,115,114,99,95,112,117,115,104,
+0,1,796185,0,115,114,99,95,112,111,112,0,1,796526,2,105,
+115,111,112,99,104,0,1,796637,4,111,112,112,114,101,102,105,
+120,0,1,796880,2,105,115,100,105,103,0,1,796941,2,105,115,
+97,108,0,1,797080,2,104,101,120,118,0,1,797212,0,101,115,
+99,99,104,0,1,797386,2,111,112,108,101,120,0,1,797531,0,
+108,101,120,0,1,798535,0,110,101,120,116,0,1,798734,2,112,
+101,101,107,97,116,0,1,798965,0,112,101,101,107,0,1,798995,
+0,110,101,120,116,48,0,1,799248,2,105,115,95,111,112,0,
+1,799324,2,105,115,95,105,100,0,1,799400,2,97,99,99,101,
+112,116,0,1,799515,2,101,120,112,101,99,116,0,1,799660,0,
+110,97,109,101,0,1,799737,2,115,101,113,97,115,109,0,1,
+800306,2,109,110,101,109,105,100,120,0,1,800408,4,101,109,105,
+116,115,101,113,0,1,800659,2,97,100,100,107,111,112,0,1,
+800779,2,98,105,110,102,105,110,100,0,1,800877,2,117,110,102,
+105,110,100,0,1,800975,2,97,115,103,102,105,110,100,0,1,
+801073,6,97,100,100,95,98,105,110,111,112,0,1,801593,4,97,
+100,100,95,117,110,111,112,0,1,801760,6,97,100,100,95,107,
+119,0,1,801843,2,102,105,110,100,108,111,99,0,1,801945,2,
+110,101,119,108,111,99,0,1,802176,2,108,114,111,111,116,0,
+1,802245,2,116,114,97,99,107,101,100,0,1,802294,2,116,111,
+117,99,104,0,1,802538,2,112,108,97,105,110,117,115,101,0,
+1,802678,2,102,114,101,101,118,97,114,0,1,802731,4,101,120,
+105,116,95,118,97,114,115,0,1,803095,2,117,110,117,115,101,
+100,95,99,104,101,99,107,0,1,803244,2,98,108,111,99,107,
+95,99,108,111,115,101,0,1,803380,0,115,110,97,112,95,112,
+117,115,104,0,1,803655,2,115,110,97,112,95,112,111,112,0,
+1,803696,2,115,110,97,112,95,114,101,115,116,111,114,101,0,
+1,803915,2,101,109,112,116,121,0,1,803991,2,115,110,97,112,
+95,99,109,112,0,1,804396,2,115,116,97,116,101,110,97,109,
+101,0,1,804614,6,109,101,114,103,101,95,101,114,114,0,1,
+804880,4,106,115,116,0,1,804955,4,106,111,119,0,1,805011,4,
+106,104,109,0,1,805067,2,101,120,105,116,95,114,101,99,0,
+1,805363,2,106,97,100,100,0,1,805467,6,106,115,97,109,101,
+0,1,805727,4,106,111,105,110,0,1,806519,6,102,105,120,117,
+112,115,0,1,806766,2,98,97,99,107,101,100,103,101,0,1,
+807557,12,106,111,105,110,50,0,1,807844,4,114,101,99,97,115,
+116,0,1,808380,4,97,114,103,99,104,101,99,107,0,1,809146,
+2,101,109,105,116,111,119,110,0,1,809195,6,97,115,115,105,
+103,110,99,104,101,99,107,0,1,810964,2,114,101,116,99,104,
+101,99,107,0,1,811455,2,104,97,110,100,117,112,0,1,811813,
+2,100,105,115,99,97,114,100,0,1,811936,2,116,97,108,108,
+111,99,0,1,812043,8,116,110,101,119,0,1,812217,2,116,112,
+116,114,0,1,812404,4,116,97,114,114,0,1,812664,8,116,102,
+110,0,1,813125,4,116,118,97,114,0,1,813321,6,116,105,110,
+115,116,0,1,813752,2,116,114,101,115,111,108,118,101,0,1,
+814288,2,116,115,122,0,1,814374,4,115,117,98,115,116,0,1,
+814873,2,105,115,110,117,109,0,1,814989,2,105,115,97,103,103,
+0,1,815071,2,105,115,112,116,114,0,1,815153,2,100,101,99,
+97,121,0,1,815216,2,116,101,108,101,109,0,1,815310,4,99,
+111,109,112,97,116,0,1,815795,6,117,110,105,102,121,0,1,
+816340,2,116,112,114,105,110,116,0,1,816962,6,116,99,101,114,
+114,0,1,817162,6,116,99,110,101,101,100,0,1,817357,2,116,
+112,102,105,110,100,0,1,817455,2,105,115,116,121,112,101,110,
+97,109,101,0,1,817573,0,99,108,111,115,101,97,110,103,108,
+101,0,1,817624,0,112,116,121,112,101,0,1,818571,0,116,115,
+116,97,114,116,0,1,818972,0,100,116,121,112,101,0,1,819159,
+0,107,119,95,115,116,114,117,99,116,0,1,820112,0,107,119,
+95,116,121,112,101,0,1,820172,0,107,119,95,116,121,112,101,
+99,104,101,99,107,0,1,820279,4,116,102,105,110,100,102,105,
+101,108,100,0,1,820403,0,116,121,112,101,97,114,103,0,1,
+820570,0,107,119,95,115,105,122,101,111,102,0,1,820628,0,107,
+119,95,116,121,112,101,111,102,0,1,820684,0,116,121,112,101,
+115,95,105,110,105,116,0,1,821266,2,105,115,110,117,109,111,
+112,0,1,821359,6,98,105,110,116,121,112,101,0,1,822752,2,
+116,107,105,110,100,0,1,822788,2,116,115,105,122,101,0,1,
+822823,2,116,110,97,109,101,0,1,822859,2,116,108,101,110,0,
+1,822895,2,116,110,102,105,101,108,100,115,0,1,822937,4,116,
+102,110,97,109,101,0,1,822993,4,116,102,116,121,112,101,0,
+1,823051,4,116,102,111,102,102,0,1,823109,2,116,114,101,116,
+0,1,823145,2,116,110,112,97,114,97,109,115,0,1,823181,4,
+116,112,97,114,97,109,0,1,823228,4,116,112,97,114,97,109,
+116,97,103,0,1,823285,2,116,114,101,116,117,0,1,823323,2,
+116,110,97,114,103,115,0,1,823418,4,116,97,114,103,0,1,
+823468,2,115,105,103,111,102,0,1,823779,2,115,105,103,111,102,
+115,0,1,823878,0,114,118,97,108,0,1,823938,4,107,119,99,
+97,108,108,0,1,824084,0,115,116,109,116,111,110,108,121,0,
+1,824162,6,97,114,103,115,0,1,824435,0,110,101,119,116,121,
+112,101,100,0,1,824605,2,99,97,108,108,0,1,825172,2,101,
+110,104,99,97,108,108,0,1,825541,0,112,114,105,109,97,114,
+121,0,1,826961,4,105,110,99,100,101,99,0,1,827385,2,102,
+105,101,108,100,0,1,828061,0,112,111,115,116,102,105,120,0,
+1,829055,0,117,110,97,114,121,0,1,829894,2,98,105,110,0,
+1,830399,0,115,116,111,114,101,107,101,101,112,0,1,830447,2,
+116,101,114,110,97,114,121,0,1,831097,0,101,120,112,114,0,
+1,831870,0,115,116,109,116,115,116,97,114,116,0,1,832117,0,
+98,108,111,99,107,101,120,112,114,0,1,832493,0,99,112,114,
+105,109,0,1,832901,0,99,101,120,112,114,0,1,833258,0,114,
+101,115,121,110,99,0,1,833385,0,115,116,109,116,0,1,833653,
+0,98,108,111,99,107,0,1,833781,0,115,117,98,115,116,109,
+116,0,1,833861,2,108,111,99,97,108,100,101,99,108,0,1,
+834496,0,107,119,95,118,97,114,0,1,834532,0,107,119,95,105,
+102,0,1,835078,4,108,111,111,112,95,112,117,115,104,0,1,
+835285,4,108,111,111,112,95,101,110,100,0,1,835815,0,107,119,
+95,119,104,105,108,101,0,1,836121,0,107,119,95,102,111,114,
+0,1,836673,0,107,119,95,98,114,101,97,107,0,1,836886,0,
+107,119,95,99,111,110,116,105,110,117,101,0,1,837173,4,99,
+97,115,101,98,111,100,121,0,1,837406,0,107,119,95,115,119,
+105,116,99,104,0,1,838058,0,107,119,95,114,101,116,117,114,
+110,0,1,838368,0,107,119,95,117,110,99,104,101,99,107,101,
+100,0,1,838428,0,97,115,109,98,108,111,99,107,0,1,839713,
+0,107,119,95,97,115,109,0,1,839755,1,103,114,97,98,0,
+1,840095,3,113,110,101,119,0,1,840173,67,113,100,117,112,0,
+1,840251,68,119,99,111,112,121,116,111,0,1,840338,0,107,119,
+95,113,117,111,116,101,0,1,840475,3,116,111,107,101,110,115,
+0,1,840715,130,102,101,101,100,0,1,840758,0,114,101,97,100,
+115,114,99,0,1,841180,0,112,115,107,105,112,97,110,103,108,
+101,0,1,841312,0,112,114,101,115,99,97,110,95,102,110,0,
+1,842125,4,112,114,101,115,99,97,110,0,1,842364,0,117,110,
+105,116,95,115,116,100,105,110,0,1,842433,0,99,116,120,95,
+112,117,115,104,0,1,842821,0,99,116,120,95,112,111,112,0,
+1,843173,4,102,110,95,98,101,103,105,110,0,1,843339,0,112,
+114,111,108,111,103,117,101,0,1,843451,0,101,112,105,108,111,
+103,117,101,0,1,843543,0,98,111,100,121,0,1,843741,2,102,
+110,100,101,102,0,1,845898,2,103,100,101,99,108,0,1,846548,
+0,103,99,111,110,115,116,0,1,846631,0,101,110,104,100,101,
+102,0,1,847934,0,116,111,112,115,121,110,99,0,1,848384,0,
+116,111,112,105,116,101,109,0,1,848933,0,117,110,105,116,95,
+116,111,112,0,1,848983,2,117,110,105,116,95,101,110,100,0,
+1,849203,4,99,111,109,112,105,108,101,95,108,105,115,116,0,
+1,849455,2,99,111,109,112,105,108,101,0,1,849491,2,108,111,
+97,100,0,1,849529,2,101,118,97,108,0,1,849580,2,101,118,
+97,108,115,0,1,849645,2,98,108,111,98,95,101,109,105,116,
+0,1,849887,2,98,108,111,98,95,108,111,97,100,0,1,850089,
+4,98,117,105,108,100,95,105,109,97,103,101,0,1,850510,0,
+122,99,95,105,110,105,116,0,1,851324,0,122,99,95,116,97,
+98,108,101,115,0,4,1048576,0,77,87,0,4,262144,0,72,69,
+65,80,95,76,79,0,4,655360,0,72,69,65,80,95,72,73,
+0,4,655360,0,90,70,80,0,4,786432,0,71,79,82,71,0,
+4,917504,0,70,66,79,84,0,4,983040,0,70,84,79,80,0,
+4,983040,0,82,83,48,0,4,1015808,0,77,65,82,75,48,0,
+4,16384,0,77,65,82,75,78,0,4,1032192,0,68,83,76,79,
+0,4,1048560,0,68,83,72,73,0,4,729683222,0,77,65,71,73,
+67,0,6,0,201337106,105,100,105,118,0,6,1,201343762,105,109,111,
+100,0,6,2,201350418,105,115,104,108,0,3,787373,0,112,111,119,
+50,0,2,787405,0,122,114,101,109,0,4,6,0,72,68,82,
+0,2,787969,0,104,98,117,109,112,0,3,787970,0,102,114,101,
+101,108,0,2,788002,0,103,99,95,114,117,110,115,0,2,788003,
+0,103,99,95,102,114,101,101,100,0,2,788004,0,103,99,95,
+97,117,116,111,0,2,789006,0,102,101,110,100,0,2,790419,0,
+109,115,95,116,111,112,0,2,790420,0,109,115,95,111,118,101,
+114,0,2,790421,0,103,99,95,108,111,0,2,790422,0,103,99,
+95,104,105,0,4,8192,0,73,72,78,0,4,655616,0,82,95,
+73,72,0,4,663808,0,82,95,80,79,79,76,0,4,704512,0,
+82,95,80,79,79,76,69,78,68,0,4,4096,0,78,83,0,
+4,704768,0,82,95,83,89,77,0,4,704768,0,115,110,97,109,
+101,0,4,708864,0,115,107,105,110,100,0,4,712960,0,115,118,
+97,108,0,4,717056,0,115,115,105,103,0,4,721152,0,115,102,
+108,97,103,0,4,725248,0,115,102,105,120,0,4,729344,0,115,
+110,101,120,116,0,4,512,0,78,76,0,4,733440,0,108,110,
+97,109,101,0,4,733952,0,108,115,108,111,116,0,4,734464,0,
+108,104,111,109,101,0,4,734976,0,108,115,116,97,116,101,0,
+4,735488,0,108,111,119,110,101,114,0,4,736000,0,108,117,115,
+101,100,0,4,736512,0,108,97,114,114,0,4,737024,0,108,111,
+119,110,0,4,8192,0,78,70,0,4,737536,0,102,115,105,116,
+101,0,4,745728,0,102,110,101,120,116,0,4,753920,0,82,95,
+83,78,65,80,0,4,762112,0,82,95,81,66,85,70,0,4,
+770304,0,82,95,83,82,67,0,4,771328,0,82,95,83,69,81,
+0,4,773376,0,98,110,97,109,101,0,4,773440,0,98,112,114,
+101,99,0,4,773504,0,98,115,101,113,0,4,773568,0,98,108,
+101,110,0,4,773632,0,117,110,97,109,101,0,4,773664,0,117,
+115,101,113,0,4,773696,0,117,108,101,110,0,4,773728,0,97,
+110,97,109,101,0,4,773792,0,97,98,105,110,0,4,773888,0,
+107,111,112,115,0,4,774400,0,82,95,67,84,88,0,4,776448,
+0,82,95,76,79,79,80,0,4,777472,0,82,95,65,83,77,
+0,4,0,0,84,95,69,79,70,0,4,1,0,84,95,78,
+85,77,0,4,2,0,84,95,73,68,0,4,3,0,84,95,
+83,84,82,0,4,4,0,84,95,79,80,0,4,1,0,75,
+95,70,78,0,4,2,0,75,95,71,86,65,82,0,4,3,
+0,75,95,71,65,82,82,0,4,4,0,75,95,67,79,78,
+83,84,0,4,5,0,75,95,75,87,0,4,6,0,75,95,
+69,78,72,0,4,7,0,75,95,84,89,80,69,0,4,1,
+0,70,95,68,69,70,0,4,2,0,70,95,83,73,71,0,
+4,4,0,70,95,85,78,84,89,80,69,68,0,4,8,0,
+70,95,83,84,77,84,0,4,16,0,70,95,69,88,80,82,
+0,4,32,0,70,95,84,79,80,0,4,64,0,70,95,70,
+65,76,76,66,65,67,75,0,4,128,0,70,95,71,69,78,
+0,4,256,0,70,95,80,82,69,0,4,0,0,83,95,80,
+76,65,73,78,0,4,1,0,83,95,77,0,4,2,0,83,
+95,85,0,4,3,0,83,95,68,0,4,4,0,83,95,68,
+69,65,68,0,4,5,0,83,95,67,72,73,76,68,0,4,
+6,0,83,95,66,79,82,82,79,87,0,4,0,0,67,95,
+80,76,65,73,78,0,4,1,0,67,95,70,82,69,83,72,
+0,4,2,0,67,95,86,65,82,0,4,0,0,76,86,95,
+78,79,78,69,0,4,1,0,76,86,95,76,79,67,65,76,
+0,4,2,0,76,86,95,71,76,79,66,65,76,0,4,3,
+0,76,86,95,69,76,69,77,0,4,4,0,76,86,95,79,
+84,72,69,82,0,4,0,0,79,95,81,0,4,1,0,79,
+95,76,68,0,4,2,0,79,95,83,84,0,4,3,0,79,
+95,80,73,67,75,0,4,4,0,79,95,68,82,79,80,0,
+4,5,0,79,95,83,87,65,80,0,4,6,0,79,95,67,
+65,76,76,0,4,7,0,79,95,74,77,80,0,4,8,0,
+79,95,74,90,0,4,9,0,79,95,82,69,84,0,4,13,
+0,79,95,65,68,68,0,4,14,0,79,95,83,85,66,0,
+4,20,0,79,95,76,84,0,4,22,0,88,79,80,48,0,
+4,-2,0,83,69,81,82,69,70,0,2,791251,0,110,101,110,
+104,0,2,791252,0,112,111,111,108,116,111,112,0,2,791253,0,
+110,115,121,109,0,2,791254,0,117,98,97,115,101,0,2,791255,
+0,118,105,115,108,111,0,2,791256,0,110,102,105,120,117,0,
+2,791257,0,102,105,120,102,114,101,101,0,2,791258,0,110,98,
+105,110,0,2,791259,0,110,117,110,0,2,791260,0,110,97,115,
+103,0,2,791261,0,110,107,111,112,0,2,791262,0,115,101,113,
+116,111,112,0,2,791263,0,109,110,101,109,0,2,791287,0,99,
+104,101,99,107,95,111,110,0,2,791288,0,116,107,0,2,791289,
+0,116,118,0,2,791290,0,116,103,108,117,101,0,2,791291,0,
+116,108,105,110,101,0,2,791292,0,108,105,110,101,0,2,791293,
+0,99,104,0,2,791294,0,99,104,107,105,110,100,0,2,791295,
+0,99,104,112,116,114,0,2,791296,0,99,104,98,97,115,101,
+0,2,791297,0,113,100,111,110,101,0,2,791298,0,105,115,112,
+0,3,791299,0,116,98,117,102,0,2,792399,0,112,107,95,116,
+107,0,2,792400,0,112,107,95,116,118,0,2,792401,0,112,113,
+95,110,0,3,792402,0,112,113,95,116,107,0,3,792406,0,112,
+113,95,116,118,0,3,792410,0,112,113,95,103,108,0,3,792414,
+0,112,113,95,108,110,0,2,792418,0,104,101,114,101,0,2,
+792419,0,104,100,101,108,116,97,0,2,792420,0,104,108,105,109,
+105,116,0,2,792421,0,112,116,111,112,0,2,792422,0,110,108,
+111,99,0,2,792423,0,108,98,97,115,101,0,2,792424,0,102,
+100,101,112,116,104,0,2,792425,0,102,115,108,111,116,115,0,
+2,792426,0,102,99,104,107,0,2,792427,0,102,114,101,116,0,
+2,792428,0,108,105,118,101,0,2,792429,0,98,120,100,101,112,
+116,104,0,2,792430,0,101,112,105,99,104,97,105,110,0,2,
+792431,0,102,102,114,97,109,101,0,2,792432,0,105,110,102,110,
+0,2,792433,0,108,115,112,0,2,792434,0,108,111,111,112,98,
+97,115,101,0,2,792435,0,99,116,120,115,112,0,2,792436,0,
+115,110,97,112,116,111,112,0,2,792437,0,108,118,0,2,792438,
+0,108,118,107,0,2,792439,0,108,118,105,0,2,792440,0,107,
+119,95,101,120,112,114,0,2,792441,0,120,99,108,115,0,2,
+792442,0,102,116,121,0,2,792443,0,115,95,108,112,0,2,792444,
+0,115,95,114,112,0,2,792445,0,115,95,108,98,0,2,792446,
+0,115,95,114,98,0,2,792447,0,115,95,108,107,0,2,792448,
+0,115,95,114,107,0,2,792449,0,115,95,99,111,109,109,97,
+0,2,792450,0,115,95,115,101,109,105,0,2,792451,0,115,95,
+101,113,0,2,792452,0,115,95,97,114,114,111,119,0,2,792453,
+0,115,95,105,110,99,0,2,792454,0,115,95,100,101,99,0,
+2,792455,0,115,95,115,116,97,114,0,2,792456,0,115,95,97,
+109,112,0,2,792457,0,115,95,99,111,108,111,110,0,2,792458,
+0,115,95,104,97,115,104,0,2,792459,0,115,95,109,105,110,
+117,115,0,2,792460,0,115,95,97,110,100,97,110,100,0,2,
+792461,0,115,95,111,114,111,114,0,2,792462,0,115,95,100,111,
+116,0,2,792463,0,115,95,102,110,0,2,792464,0,115,95,118,
+97,114,0,2,792465,0,115,95,99,111,110,115,116,0,2,792466,
+0,115,95,101,108,115,101,0,2,792467,0,115,95,97,115,0,
+2,792468,0,115,95,117,110,99,104,101,99,107,101,100,0,2,
+792469,0,115,95,105,109,109,101,100,105,97,116,101,0,2,792470,
+0,115,95,109,0,2,792471,0,115,95,100,0,2,792472,0,115,
+95,117,0,2,792473,0,115,95,113,0,2,792474,0,115,95,99,
+97,115,101,0,2,792475,0,115,95,100,101,102,97,117,108,116,
+0,2,792476,0,115,95,102,111,118,102,0,2,792477,0,115,95,
+115,116,97,114,116,0,2,792478,0,115,95,109,97,105,110,0,
+2,792479,0,115,95,102,114,101,101,0,2,792480,0,115,95,111,
+119,110,0,2,792481,0,115,95,113,110,101,119,0,2,792482,0,
+115,95,101,110,104,97,110,99,101,0,2,792483,0,115,95,109,
+105,99,114,111,0,2,792484,0,115,95,118,109,0,4,0,0,
+84,89,95,87,79,82,68,0,4,1,0,84,89,95,73,78,
+84,0,4,2,0,84,89,95,67,72,65,82,0,4,3,0,
+84,89,95,66,79,79,76,0,4,4,0,84,89,95,86,79,
+73,68,0,4,5,0,84,89,95,80,84,82,0,4,6,0,
+84,89,95,65,82,82,0,4,7,0,84,89,95,70,78,0,
+4,8,0,84,89,95,83,84,82,85,67,84,0,4,9,0,
+84,89,95,86,65,82,0,4,10,0,84,89,95,71,69,78,
+0,4,638976,0,82,95,84,89,0,4,655360,0,82,95,84,89,
+69,78,68,0,4,1024,0,78,84,76,0,4,778496,0,108,116,
+121,112,101,0,4,779008,0,108,116,97,103,0,4,779520,0,115,
+116,121,112,101,0,2,792485,0,116,121,116,111,112,0,2,792486,
+0,110,116,108,0,2,792487,0,116,119,111,114,100,0,2,792488,
+0,116,105,110,116,0,2,792489,0,116,99,104,97,114,0,2,
+792490,0,116,98,111,111,108,0,2,792491,0,116,118,111,105,100,
+0,2,792492,0,116,99,95,111,110,0,2,792493,0,120,116,121,
+0,2,792494,0,120,122,101,114,111,0,2,792495,0,100,114,121,
+0,3,792496,0,116,112,110,0,2,792504,0,110,116,112,0,2,
+792505,0,100,116,121,0,2,792506,0,100,116,97,103,0,2,792507,
+0,115,95,108,116,0,2,792508,0,115,95,103,116,0,2,792509,
+0,115,95,115,104,114,0,2,792510,0,115,95,108,101,0,2,
+792511,0,115,95,103,101,0,2,792512,0,115,95,101,113,101,113,
+0,2,792513,0,115,95,110,101,0,2,792514,0,115,95,112,108,
+117,115,0,2,792515,0,115,95,115,116,114,117,99,116,0,2,
+792516,0,115,95,116,121,112,101,0,2,792517,0,115,95,116,121,
+112,101,99,104,101,99,107,0,2,792518,0,115,95,111,110,0,
+2,792519,0,115,95,111,102,102,0,2,792520,0,115,95,110,101,
+119,0,2,792521,0,115,95,110,101,119,95,116,0,3,792522,0,
+110,117,109,111,112,115,0,2,792534,0,110,110,117,109,111,112,
+115,0,3,792535,0,103,98,105,110,100,0,2,792543,0,110,103,
+98,105,110,100,0,2,792544,0,110,101,114,114,0,2,792545,0,
+112,97,110,105,99,0,4,783616,0,82,95,69,88,73,84,0,
+4,786176,0,82,95,69,88,73,84,69,78,68,0,2,804814,0,
+101,120,116,111,112,0,3,804815,0,106,112,115,0,2,804879,0,
+110,106,112,115,0,0
+};
+#define GLEN 71014
diff --git a/docs/history/13-gap-fixes/code/io_linux.c b/docs/history/13-gap-fixes/code/io_linux.c
new file mode 100644
index 0000000..7ea34e0
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/io_linux.c
@@ -0,0 +1,6 @@
+#include <stdio.h>
+int J;
+static int pk(void){int c=getchar();ungetc(c,stdin);return c==EOF;}
+char Q(void){int c=getchar();J=pk();return c;}
+void G(char c){putchar(c);}
+__attribute__((constructor)) static void init(void){J=pk();}
diff --git a/docs/history/13-gap-fixes/code/mkgenome.c b/docs/history/13-gap-fixes/code/mkgenome.c
new file mode 100644
index 0000000..8fb2cc5
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/mkgenome.c
@@ -0,0 +1,16 @@
+/* turns a genome image (little-endian 32-bit words on stdin, as written by
+   tools/build.zc) into genome.h */
+#include <stdio.h>
+#define GORG 0xC0000
+int main(void)
+{
+	unsigned char b[4]; int n = 0;
+	printf("#define GORG %d\nstatic const int genome[] = {", GORG);
+	while (fread(b, 1, 4, stdin) == 4) {
+		int w = (int)(b[0] | b[1] << 8 | b[2] << 16 | (unsigned)b[3] << 24);
+		printf("%s%d", !n ? "\n" : n % 16 ? "," : ",\n", w);
+		n++;
+	}
+	printf("\n};\n#define GLEN %d\n", n);
+	return n ? 0 : 1;
+}
diff --git a/docs/history/13-gap-fixes/code/src/compiler.zc b/docs/history/13-gap-fixes/code/src/compiler.zc
new file mode 100644
index 0000000..c6fa3cc
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/src/compiler.zc
@@ -0,0 +1,2638 @@
+// ============================================================================
+// compiler.zc: the resident zc compiler. it lives in the genome next to the
+// runtime, compiles source straight to vm words in memory, and is visible to
+// the programs it compiles: every function and global here can be called or
+// patched by name, and parse words (immediate fns) run inside it.
+// ============================================================================
+
+// ---- compiler data region (fixed addresses, 0xA0100 .. 0xBE100) ----
+const IHN = 8192;
+const R_IH = 0xA0100;		// intern hash table
+const R_POOL = 0xA2100;		// interned strings: [symbol head] chars 0
+const R_POOLEND = 0xAC000;
+const NS = 4096;		// symbol table, one array per field
+const R_SYM = 0xAC100;
+const sname = 0xAC100, skind = 0xAD100, sval = 0xAE100, ssig = 0xAF100;
+const sflag = 0xB0100, sfix = 0xB1100, snext = 0xB2100;
+const NL = 512;			// locals, one array per field
+const lname = 0xB3100, lslot = 0xB3300, lhome = 0xB3500, lstate = 0xB3700;
+const lowner = 0xB3900, lused = 0xB3B00, larr = 0xB3D00, lown = 0xB3F00;	// lown: has owned an object
+const NF = 8192;		// patch nodes: a site and a link
+const fsite = 0xB4100, fnext = 0xB6100;
+const R_SNAP = 0xB8100;		// analyzer snapshots
+const R_QBUF = 0xBA100;		// token buffer for quote and grab
+const R_SRC = 0xBC100;		// input source stack, 32 words per frame
+const R_SEQ = 0xBC500;		// operator code sequences
+const bname = 0xBCD00, bprec = 0xBCD40, bseq = 0xBCD80, blen = 0xBCDC0;	// binary operators
+const uname = 0xBCE00, useq = 0xBCE20, ulen = 0xBCE40;		// unary operators
+const aname = 0xBCE60, abin = 0xBCEA0;				// compound assignment
+const kops = 0xBCF00;		// every operator spelling the lexer knows
+const R_CTX = 0xBD100;		// saved compiler contexts for nested compiles
+const R_LOOP = 0xBD900;		// loop stack, 8 words per loop or switch
+const R_ASM = 0xBDD00;		// asm block labels
+
+// ---- token kinds, symbol kinds and flags ----
+const T_EOF = 0, T_NUM = 1, T_ID = 2, T_STR = 3, T_OP = 4;
+const K_FN = 1, K_GVAR = 2, K_GARR = 3, K_CONST = 4, K_KW = 5, K_ENH = 6, K_TYPE = 7;
+const F_DEF = 1, F_SIG = 2, F_UNTYPED = 4, F_STMT = 8, F_EXPR = 16, F_TOP = 32, F_FALLBACK = 64, F_GEN = 128, F_PRE = 256;
+// variable states for the lifetime analyzer
+const S_PLAIN = 0, S_M = 1, S_U = 2, S_D = 3, S_DEAD = 4, S_CHILD = 5, S_BORROW = 6;
+// expression classes: plain word, a new object, or a bare variable (C_VAR + index)
+const C_PLAIN = 0, C_FRESH = 1, C_VAR = 2;
+// lvalue kinds
+const LV_NONE = 0, LV_LOCAL = 1, LV_GLOBAL = 2, LV_ELEM = 3, LV_OTHER = 4;
+// opcodes
+const O_Q = 0, O_LD = 1, O_ST = 2, O_PICK = 3, O_DROP = 4, O_SWAP = 5, O_CALL = 6, O_JMP = 7;
+const O_JZ = 8, O_RET = 9, O_ADD = 13, O_SUB = 14, O_LT = 20;
+const XOP0 = 22;			// first enhancement opcode
+const SEQREF = -2;		// in an operator sequence: the next word names a symbol
+
+// ---- state ----
+let nenh, pooltop, nsym, ubase, vislo, nfixu, fixfree;
+let nbin, nun, nasg, nkop, seqtop;
+let mnem = "q@!$_~cjzr,?.+-*&|^><%";
+let check_on = 1;		// set to 0 to switch the analyzer off for what follows
+let tk, tv, tglue, tline, line = 1, ch, chkind, chptr, chbase, qdone, isp = -1;
+let tbuf[1100];
+let pk_tk, pk_tv, pq_n, pq_tk[4], pq_tv[4], pq_gl[4], pq_ln[4];	// up to 4 tokens of lookahead
+let here, hdelta, hlimit, ptop;
+let nloc, lbase, fdepth, fslots, fchk, fret, live, bxdepth, epichain, fframe, infn;
+let lsp, loopbase, ctxsp, snaptop;
+let lv, lvk, lvi, kw_expr, xcls, fty;
+// interned spellings the parser compares against
+let s_lp, s_rp, s_lb, s_rb, s_lk, s_rk, s_comma, s_semi, s_eq, s_arrow, s_inc, s_dec;
+let s_star, s_amp, s_colon, s_hash, s_minus, s_andand, s_oror;
+let s_dot, s_fn, s_var, s_const, s_else, s_as, s_unchecked, s_immediate, s_m, s_d, s_u;
+let s_q, s_case, s_default, s_fovf, s_start, s_main, s_free, s_own, s_qnew, s_enhance, s_micro, s_vm;
+
+// ---- types: kinds, tables and parser state (see the types section) ----
+const TY_WORD = 0, TY_INT = 1, TY_CHAR = 2, TY_BOOL = 3, TY_VOID = 4, TY_PTR = 5, TY_ARR = 6;
+const TY_FN = 7, TY_STRUCT = 8, TY_VAR = 9, TY_GEN = 10;
+const R_TY = 0x9C000, R_TYEND = 0xA0000, NTL = 1024;	// the first NTL words list every record
+const ltype = 0xBE100, ltag = 0xBE300, stype = 0xBE500;	// type per local, declared tag per local, type per symbol
+let tytop, ntl, tword, tint, tchar, tbool, tvoid;
+let tc_on;			// the optional typechecker, off unless a program says typecheck on;
+let xty, xzero, dry;		// type of the last expression, was it a literal 0, and dry runs (typeof)
+let tpn[8], ntp;		// type parameters in scope
+let dty, dtag;			// result of dtype()
+let s_lt, s_gt, s_shr, s_le, s_ge, s_eqeq, s_ne, s_plus, s_struct, s_type, s_typecheck, s_on, s_off, s_new, s_new_t;
+let numops[12], nnumops;
+let gbind[8], ngbind;		// explicit type arguments for the next call: f<int>(...)
+
+// ---- errors ----
+// the compiler reports up to 20 errors before it stops. a syntax error
+// (die) skips the token it happened on and sets panic, which skips ahead to
+// the next ; or } (or the next top-level item) and keeps quiet until then.
+// other errors (serr) just report: the parse is still in step.
+let nerr, panic;
+fn errat() { puts("zc: line "); putn(tline); puts(": "); nerr++; return 0; }
+fn errend() { putc(10); if (nerr >= 20) { puts("zc: too many errors, stopping\n"); halt(); } return 0; }
+fn giveup() { puts("zc: "); putn(nerr); if (nerr == 1) puts(" error\n"); else puts(" errors\n"); halt(); return 0; }
+fn fatal(msg) { errat(); puts(msg); putc(10); halt(); return 0; }
+fn serr(msg) { if (!panic && !dry) { errat(); puts(msg); errend(); } return 0; }
+fn serrn(name, msg) { if (!panic && !dry) { errat(); puts(name); puts(": "); puts(msg); errend(); } return 0; }
+fn die(msg) { serr(msg); panic = 1; if (tk == T_EOF) giveup(); next(); return 0; }
+fn dien(name, msg) { serrn(name, msg); panic = 1; if (tk == T_EOF) giveup(); next(); return 0; }
+// analyzer errors only count in checked, reachable code
+fn cerr(msg) { if (fchk && live) serr(msg); return 0; }
+fn cerrn(i, msg) { if (fchk && live) serrn(lname[i], msg); return 0; }
+
+// ---- interning ----
+fn hashs(s) { let h = 0; while (*s) { h = h * 31 + *s; s++; } return h & (IHN - 1); }
+fn intern(s)
+{
+	let h = hashs(s), p, n;
+	while (1) {
+		p = R_IH[h];
+		if (!p) break;
+		if (streq(p, s)) return p;
+		h = (h + 1) & (IHN - 1);
+	}
+	n = strlen(s);
+	if (pooltop + n + 2 >= R_POOLEND) fatal("string pool full");
+	pooltop[0] = 0;
+	p = pooltop + 1;
+	wcopy(p, s, n + 1);
+	pooltop = pooltop + n + 2;
+	R_IH[h] = p;
+	return p;
+}
+
+// ---- symbols ----
+// each interned name keeps the index (+1) of its newest symbol in p[-1], and
+// each symbol links to the one it shadows, so lookup is one step.
+fn addsym(name, kind, val)
+{
+	let i = nsym;
+	if (nsym >= NS) fatal("symbol table full");
+	nsym++;
+	sname[i] = name; skind[i] = kind; sval[i] = val; ssig[i] = 0; sflag[i] = F_DEF; sfix[i] = 0; stype[i] = 0;
+	snext[i] = name[-1];
+	name[-1] = i + 1;
+	return i;
+}
+// while an image builds, names below vislo are hidden, except keywords
+fn lookup(name)
+{
+	let i = name[-1] - 1;
+	while (i >= 0) {
+		if (i >= vislo || skind[i] == K_KW || skind[i] == K_TYPE) return i;
+		i = snext[i] - 1;
+	}
+	return -1;
+}
+fn popsyms(to) { while (nsym > to) { nsym--; sname[nsym][-1] = snext[nsym]; } return 0; }
+fn lookups(s) { return lookup(intern(s)); }
+
+// patch nodes
+fn fixnew(site, link)
+{
+	let i = fixfree;
+	if (i) fixfree = fnext[i];
+	else { nfixu++; i = nfixu; if (i >= NF) fatal("too many forward references"); }
+	fsite[i] = site; fnext[i] = link;
+	return i;
+}
+// patch every lit in a chain to point at v, and recycle the nodes
+fn fixall(head, v)
+{
+	let n;
+	while (head) { setlit(fsite[head], v); n = fnext[head]; fnext[head] = fixfree; fixfree = head; head = n; }
+	return 0;
+}
+
+// ---- code emission ----
+fn emit(w) { if (dry) return 0; if (here >= hlimit) fatal("program too big"); *(here + hdelta) = w; here++; return 0; }
+fn lit(v) { emit(v + v + 1); return 0; }
+fn op(k) { emit(k + k); return 0; }
+fn setlit(at, v) { if (dry) return 0; *(at + hdelta) = v + v + 1; return 0; }
+fn jmp(t) { lit(t); op(O_JMP); return 0; }
+// a lit that will be patched later; returns its address
+fn hole() { let a = here; lit(MW - 1); return a; }
+fn fwdfn(name) { let s = addsym(name, K_FN, tline); sflag[s] = 0; return s; }	// the line of the first use, until it's defined
+fn fnref(s)
+{
+	if (sflag[s] & F_DEF) { lit(sval[s]); return 0; }
+	if (dry) return 0;
+	sfix[s] = fixnew(here, sfix[s]);
+	lit(MW - 1);		// a jump to MW-1 halts if it ever runs unpatched
+	return 0;
+}
+fn callname(name) { let s = lookup(name); if (s < 0) s = fwdfn(name); fnref(s); op(O_CALL); return 0; }
+fn laddr(k) { lit(ZFP); op(O_LD); if (k) { lit(k); op(O_ADD); } return 0; }
+fn strlit(s)
+{
+	let j = hole(), a;
+	op(O_JMP);
+	a = here;
+	while (*s) { emit(*s); s++; }
+	emit(0);
+	setlit(j, here);
+	lit(a);
+	return 0;
+}
+
+// ---- input sources ----
+// frame: 0 kind (0 stdin, 1 token list, 2 string)  1 object  2 index  3 end
+// 4 transparent  5..7 saved token  8..10 saved char state  11 owned  12 saved line
+// 13 saved token line  14 saved lookahead count  15..30 saved lookahead  31 saved char buffer
+fn nextch()
+{
+	if (chkind == 0) {
+		if (qdone || eof()) { ch = -1; return 0; }
+		ch = getc() & 255;
+		if (ch == 96) { qdone = 1; ch = -1; return 0; }	// a backtick ends the source
+	} else if (chkind == 3) {
+		ch = (chbase[chptr >> 2] >> ((chptr & 3) * 8)) & 255;
+		if (ch) chptr++; else ch = -1;
+	} else {
+		ch = *chptr & 255;
+		if (ch) chptr++; else ch = -1;
+	}
+	if (ch == 10) line++;
+	return 0;
+}
+fn src_push(kind, obj, trans, owned)
+{
+	let f, i;
+	isp++;
+	if (isp >= 32) fatal("sources nested too deeply");
+	f = R_SRC + isp * 32;
+	f[0] = kind; f[1] = obj; f[2] = 0; f[3] = 0; f[4] = trans; f[11] = owned;
+	f[5] = tk; f[6] = tv; f[7] = tglue; f[8] = ch; f[9] = chkind; f[10] = chptr;
+	f[12] = line; f[13] = tline; f[14] = pq_n; f[31] = chbase;
+	i = 0; while (i < pq_n) { f[15 + i * 4] = pq_tk[i]; f[16 + i * 4] = pq_tv[i]; f[17 + i * 4] = pq_gl[i]; f[18 + i * 4] = pq_ln[i]; i++; }
+	pq_n = 0;
+	if (kind == 1) f[3] = obj[0];
+	if (kind == 0) { chkind = 0; qdone = 0; line = 1; nextch(); }
+	if (kind == 2) { chkind = 2; chptr = obj; line = 1; nextch(); }
+	if (kind == 3) { chkind = 3; chbase = obj; chptr = 0; line = 1; nextch(); }
+	return 0;
+}
+fn src_pop()
+{
+	let f = R_SRC + isp * 32, i = 0;
+	tk = f[5]; tv = f[6]; tglue = f[7]; ch = f[8]; chkind = f[9]; chptr = f[10];
+	line = f[12]; tline = f[13]; pq_n = f[14]; chbase = f[31];
+	while (i < pq_n) { pq_tk[i] = f[15 + i * 4]; pq_tv[i] = f[16 + i * 4]; pq_gl[i] = f[17 + i * 4]; pq_ln[i] = f[18 + i * 4]; i++; }
+	isp--;
+	if (f[11]) free(f[1]);
+	return 0;
+}
+fn isopch(c)
+{
+	let s = "+-*/%=<>!&|^~?:.@#$";
+	while (*s) { if (*s == c) return 1; s++; }
+	return 0;
+}
+// is buf[0..n) followed by c the start of some operator the lexer knows?
+fn opprefix(n, c)
+{
+	let i = 0, k, j;
+	while (i < nkop) {
+		k = kops[i];
+		j = 0;
+		while (j < n && k[j] == tbuf[j]) j++;
+		if (j == n && k[n] == c) return 1;
+		i++;
+	}
+	return 0;
+}
+fn isdig(c) { return c >= '0' && c <= '9'; }
+fn isal(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'; }
+fn hexv(c)
+{
+	if (isdig(c)) return c - '0';
+	if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+	if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+	return -1;
+}
+fn escch()
+{
+	let c = ch;
+	nextch();
+	if (c != 92) return c;
+	c = ch;
+	nextch();
+	if (c == 'n') return 10;
+	if (c == 't') return 9;
+	if (c == 'r') return 13;
+	if (c == '0') return 0;
+	if (c == 'e') return 27;
+	return c;
+}
+fn oplex(n)
+{
+	while (ch >= 0 && isopch(ch) && opprefix(n, ch)) { tbuf[n] = ch; n++; nextch(); }
+	tbuf[n] = 0;
+	tk = T_OP; tv = intern(tbuf);
+	return 0;
+}
+fn lex()
+{
+	let n = 0, v, dg;
+	tglue = 1;
+	while (1) {
+		while (ch == 32 || ch == 9 || ch == 10 || ch == 13) { nextch(); tglue = 0; }
+		if (ch != '/') break;
+		nextch();
+		if (ch == '/') { while (ch >= 0 && ch != 10) nextch(); tglue = 0; continue; }
+		if (ch == '*') {
+			nextch();
+			while (ch >= 0) { if (ch == '*') { nextch(); if (ch == '/') break; } else nextch(); }
+			nextch(); tglue = 0; continue;
+		}
+		tline = line; tbuf[0] = '/'; oplex(1); return 0;
+	}
+	tline = line;
+	if (ch < 0) { tk = T_EOF; tv = 0; return 0; }
+	if (isdig(ch)) {
+		v = 0;
+		if (ch == '0') {
+			nextch();
+			if (ch == 'x' || ch == 'X') {
+				nextch();
+				while ((dg = hexv(ch)) >= 0) { v = v * 16 + dg; nextch(); }
+				tk = T_NUM; tv = v; return 0;
+			}
+		}
+		while (isdig(ch)) { v = v * 10 + ch - '0'; nextch(); }
+		tk = T_NUM; tv = v; return 0;
+	}
+	if (isal(ch)) {
+		while (isal(ch) || isdig(ch)) { if (n < 1000) { tbuf[n] = ch; n++; } nextch(); }
+		tbuf[n] = 0;
+		tk = T_ID; tv = intern(tbuf); return 0;
+	}
+	if (ch == 39) { nextch(); tv = escch(); if (ch != 39) die("bad character literal"); nextch(); tk = T_NUM; return 0; }
+	if (ch == 34) {
+		nextch();
+		while (ch >= 0 && ch != 34) { v = escch(); if (n < 1000) { tbuf[n] = v; n++; } }
+		nextch();
+		tbuf[n] = 0;
+		tk = T_STR; tv = intern(tbuf); return 0;
+	}
+	tbuf[0] = ch;
+	nextch();
+	if (isopch(tbuf[0])) return oplex(1);
+	tbuf[1] = 0;
+	tk = T_OP; tv = intern(tbuf);
+	return 0;
+}
+// one token of lookahead: peek() fills pk_*, next() takes it first
+fn next()
+{
+	let i = 1;
+	if (pq_n) {
+		tk = pq_tk[0]; tv = pq_tv[0]; tglue = pq_gl[0]; tline = pq_ln[0];
+		while (i < pq_n) { pq_tk[i - 1] = pq_tk[i]; pq_tv[i - 1] = pq_tv[i]; pq_gl[i - 1] = pq_gl[i]; pq_ln[i - 1] = pq_ln[i]; i++; }
+		pq_n--;
+		return 0;
+	}
+	return next0();
+}
+// the k-th token after the current one (k from 0 to 3), into pk_tk and pk_tv
+fn peekat(k)
+{
+	let a, b, c, e;
+	while (pq_n <= k) {
+		a = tk; b = tv; c = tglue; e = tline;
+		next0();
+		pq_tk[pq_n] = tk; pq_tv[pq_n] = tv; pq_gl[pq_n] = tglue; pq_ln[pq_n] = tline; pq_n++;
+		tk = a; tv = b; tglue = c; tline = e;
+	}
+	pk_tk = pq_tk[k]; pk_tv = pq_tv[k];
+	return 0;
+}
+fn peek() { return peekat(0); }
+fn next0()
+{
+	let f, q, i;
+	f = R_SRC + isp * 32;
+	if (f[0] != 1) { lex(); return 0; }
+	i = f[2];
+	if (i < f[3]) { q = f[1]; tk = q[1 + i * 3]; tv = q[2 + i * 3]; tline = q[3 + i * 3]; tglue = 0; f[2] = i + 1; return 0; }
+	if (!f[4]) { tk = T_EOF; tv = 0; return 0; }
+	src_pop();		// a fed list ran out: continue with the token that followed it
+	return 0;
+}
+fn is_op(s) { return tk == T_OP && tv == s; }
+fn is_id(s) { return tk == T_ID && tv == s; }
+fn accept(s) { if ((tk == T_OP || tk == T_ID) && tv == s) { next(); return 1; } return 0; }
+fn expect(s) { if (!accept(s)) { if (!panic && !dry) { errat(); puts("expected "); puts(s); errend(); } panic = 1; if (tk == T_EOF) giveup(); } return 0; }
+fn name()
+{
+	let n = tv;
+	if (tk != T_ID) die("expected a name");
+	next();
+	return n;
+}
+
+// ---- operator tables ----
+// a sequence is written like asm: one-char mnemonics, numbers, and names
+// (resolved when the operator is used, so image builds stay self-contained)
+fn seqasm(s)
+{
+	let start = seqtop, n, neg, v, k, c;
+	while (1) {
+		while (*s == 32) s++;
+		if (!*s) break;
+		n = 0;
+		while (s[n] && s[n] != 32) { tbuf[n] = s[n]; n++; }
+		tbuf[n] = 0;
+		s = s + n;
+		neg = tbuf[0] == '-' && isdig(tbuf[1]);
+		if (isdig(tbuf[neg])) {
+			v = 0; k = neg;
+			while (tbuf[k]) { v = v * 10 + tbuf[k] - '0'; k++; }
+			if (neg) v = 0 - v;
+			R_SEQ[seqtop] = v + v + 1; seqtop++;
+		} else if (n == 1 && (c = mnemidx(tbuf[0])) >= 0) {
+			R_SEQ[seqtop] = c + c; seqtop++;
+		} else {
+			R_SEQ[seqtop] = SEQREF; R_SEQ[seqtop + 1] = intern(tbuf); seqtop = seqtop + 2;
+		}
+	}
+	return start;
+}
+fn mnemidx(c) { let i = 0; while (mnem[i]) { if (mnem[i] == c) return i; i++; } return -1; }
+fn emitseq(a, n)
+{
+	let e = a + n, s;
+	while (a < e) {
+		if (R_SEQ[a] == SEQREF) {
+			s = lookup(R_SEQ[a + 1]);
+			if (s < 0) s = fwdfn(R_SEQ[a + 1]);
+			if (skind[s] == K_FN) fnref(s); else if (skind[s] == K_ENH) op(XOP0 + sval[s]); else lit(sval[s]);
+			a = a + 2;
+		} else { emit(R_SEQ[a]); a++; }
+	}
+	return 0;
+}
+fn addkop(p) { let i = 0; while (i < nkop) { if (kops[i] == p) return 0; i++; } kops[nkop] = p; nkop++; return 0; }
+fn binfind(p) { let i = nbin; while (i) { i--; if (bname[i] == p) return i; } return -1; }
+fn unfind(p) { let i = nun; while (i) { i--; if (uname[i] == p) return i; } return -1; }
+fn asgfind(p) { let i = nasg; while (i) { i--; if (aname[i] == p) return i; } return -1; }
+// add or replace a binary operator. code is a sequence string, or 0 for the
+// built-in && (prec 2) and || (prec 1) behaviour, chosen by -1 / -2 in prec.
+fn add_binop(nm, prec, code)
+{
+	let p = intern(nm), i = binfind(p), a, n;
+	if (i < 0) { i = nbin; nbin++; }
+	bname[i] = p; bprec[i] = prec;
+	if (prec < 0) { bprec[i] = 0 - prec; blen[i] = prec; bseq[i] = 0; addkop(p); return i; }
+	bseq[i] = seqasm(code); blen[i] = seqtop - bseq[i];
+	addkop(p);
+	// and its compound assignment, x op= y
+	n = strlen(nm);
+	wcopy(tbuf + 1000, nm, n);
+	tbuf[1000 + n] = '='; tbuf[1001 + n] = 0;
+	a = intern(tbuf + 1000);
+	if (prec >= 8 || prec == 5 || prec == 4 || prec == 3) {
+		if (asgfind(a) < 0) { aname[nasg] = a; nasg++; }
+		abin[asgfind(a)] = i;
+		addkop(a);
+	}
+	return i;
+}
+fn add_unop(nm, code)
+{
+	let p = intern(nm), i = unfind(p);
+	if (i < 0) { i = nun; nun++; }
+	uname[i] = p; useq[i] = seqasm(code); ulen[i] = seqtop - useq[i];
+	addkop(p);
+	return i;
+}
+fn add_kw(nm, handler, flags) { let s = addsym(intern(nm), K_KW, handler); sflag[s] = F_DEF | flags; return s; }
+
+// ---- locals and the analyzer's view of them ----
+fn findloc(n) { let i = nloc; while (i > lbase) { i--; if (lname[i] == n) return i; } return -1; }
+fn newloc(n)
+{
+	let i = nloc;
+	if (nloc >= NL) fatal("too many locals");
+	nloc++;
+	lname[i] = n; lslot[i] = fslots; lhome[i] = fdepth; lstate[i] = S_PLAIN;
+	lowner[i] = 0; lused[i] = 0; larr[i] = 0; lown[i] = 0; ltype[i] = tword; ltag[i] = 0;
+	return i;
+}
+fn lroot(i) { while (lstate[i] == S_CHILD) i = lowner[i]; return i; }
+fn tracked(i) { return lstate[i] != S_PLAIN; }
+// a use that doesn't give the object away
+fn touch(i)
+{
+	let r;
+	lused[i] = 1;
+	if (!fchk) return 0;
+	r = lroot(i);
+	lused[r] = 1;
+	if (lstate[r] == S_DEAD) { cerrn(i, "used after it was given away"); return 0; }
+	// a d object that shows up in a deeper block is given to that block
+	if (lstate[r] == S_D && lhome[r] < fdepth) { lhome[r] = fdepth; lstate[r] = S_M; lown[r] = 1; }
+	return 0;
+}
+fn plainuse(c)
+{
+	if (c == C_FRESH) cerr("a new object can't be used as a plain value; bind it to a name first");
+	if (c >= C_VAR) touch(c - C_VAR);
+	return C_PLAIN;
+}
+fn freevar(i) { laddr(lslot[i]); op(O_LD); callname(s_free); op(O_DROP); return 0; }
+// leaving every block deeper than or equal to dep: free what is owned, and
+// complain about what should have left already. final means the block really
+// ends here rather than an early exit.
+fn exit_vars(dep, final)
+{
+	let i = nloc, st;
+	if (!fchk || !live) return 0;
+	while (i > lbase) {
+		i--;
+		if (lhome[i] < dep) continue;
+		st = lstate[i];
+		if (st == S_M) freevar(i); else if (st == S_U) cerrn(i, "u object must leave this block (block value, assignment to the enclosing block, or return)");
+		else if (st == S_D) cerrn(i, "d object was never given away");
+	}
+	return 0;
+}
+// an m object has to be used somewhere in the block that owns it, on any path
+fn unused_check(from)
+{
+	while (from < nloc) { if (fchk && lown[from] && !lused[from]) serrn(lname[from], "m object is never used"); from++; }
+	return 0;
+}
+fn block_close(save)
+{
+	let i = lbase;
+	unused_check(save);
+	exit_vars(fdepth, 1);
+	while (i < save) { if (lhome[i] >= fdepth) { lstate[i] = S_DEAD; lhome[i] = fdepth - 1; } i++; }
+	nloc = save;
+	return 0;
+}
+
+// snapshots: [lbase] [nloc] then state, owner, home per local
+fn snap_push()
+{
+	let b = snaptop, i = lbase, p;
+	p = R_SNAP + b;
+	p[0] = lbase; p[1] = nloc;
+	p = p + 2;
+	while (i < nloc) { p[0] = lstate[i]; p[1] = lowner[i]; p[2] = lhome[i]; p = p + 3; i++; }
+	snaptop = p - R_SNAP;
+	if (snaptop >= 8000) fatal("nesting too deep for the analyzer");
+	return b;
+}
+fn snap_pop(b) { snaptop = b; return 0; }
+fn snap_restore(b)
+{
+	let p = R_SNAP + b, i = p[0], e = p[1];
+	if (e > nloc) e = nloc;
+	p = p + 2;
+	while (i < e) { lstate[i] = p[0]; lowner[i] = p[1]; lhome[i] = p[2]; p = p + 3; i++; }
+	return 0;
+}
+fn empty(s) { return s == S_PLAIN || s == S_DEAD; }
+// compare the current states with a snapshot: -1 if they agree, else the
+// first local that differs. plain and dead agree and merge to dead.
+fn snap_cmp(b)
+{
+	let p = R_SNAP + b, i = p[0], e = p[1], s;
+	if (e > nloc) e = nloc;
+	p = p + 2;
+	while (i < e) {
+		s = lstate[i];
+		if (empty(s) && empty(p[0])) { if (p[0] == S_DEAD) lstate[i] = S_DEAD; }
+		else if (s != p[0] || lhome[i] != p[2] || (s == S_CHILD && lowner[i] != p[1])) return i;
+		p = p + 3; i++;
+	}
+	return -1;
+}
+fn statename(s)
+{
+	if (s == S_PLAIN) return "empty";
+	if (s == S_M) return "m";
+	if (s == S_U) return "u";
+	if (s == S_D) return "d";
+	if (s == S_DEAD) return "given away";
+	if (s == S_CHILD) return "owned by a container";
+	return "borrowed";
+}
+fn merge_err(i, sa, what)
+{
+	if (!fchk || panic || dry) return 0;
+	errat(); puts(lname[i]); puts(": "); puts(what);
+	puts(" (one path leaves it "); puts(statename(sa)); puts(", another "); puts(statename(lstate[i])); puts(")");
+	errend();
+	return 0;
+}
+// after an if: the current state is the else path, sa is the then path
+
+// ---- joins ----
+// where control flow comes back together (after an if, a loop, a switch or
+// ?:) every variable has to agree across the paths that reach the join. one
+// exception: a variable that became d, or was given away, on some path is dead
+// after the join, and the paths where it's still alive free it on the way in
+// (fixups). u objects and borrows don't get this treatment: a u object still
+// has to leave, and a borrow never changes.
+const R_EXIT = 0xBF500, R_EXITEND = 0xBFF00;	// exit records: the states at each break
+let extop, jps[64], njps;			// the paths being joined: [lbase, nloc, triples]
+fn jst(p, i) { if (i >= p[1]) return S_PLAIN; return p[2 + 3 * (i - p[0])]; }
+fn jow(p, i) { return p[3 + 3 * (i - p[0])]; }
+fn jhm(p, i) { return p[4 + 3 * (i - p[0])]; }
+// the states at a break, with the jump to patch: [site] then a snapshot
+fn exit_rec(site)
+{
+	let p = R_EXIT + extop, i = lbase, q;
+	if (extop + 3 + 3 * (nloc - lbase) >= R_EXITEND - R_EXIT) fatal("too many breaks for the analyzer");
+	p[0] = site; p[1] = lbase; p[2] = nloc;
+	q = p + 3;
+	while (i < nloc) { q[0] = lstate[i]; q[1] = lowner[i]; q[2] = lhome[i]; q = q + 3; i++; }
+	extop = q - R_EXIT;
+	return p;
+}
+fn jadd(p) { if (njps >= 64) fatal("too many paths for the analyzer"); jps[njps] = p; njps++; return 0; }
+fn jsame(p, q, i)
+{
+	let s = jst(p, i), t = jst(q, i);
+	if (empty(s) && empty(t)) return 1;
+	return s == t && jhm(p, i) == jhm(q, i) && (s != S_CHILD || jow(p, i) == jow(q, i));
+}
+// join the paths in jps over the locals [lbase, n0) into the current states
+fn join(n0, what)
+{
+	let i = lbase, j, p, s, s0, dead, okdead, bad;
+	if (!njps) return 0;
+	while (i < n0) {
+		p = jps[0]; s0 = jst(p, i);
+		dead = 0; okdead = 1; bad = -1;
+		j = 0;
+		while (j < njps) {
+			s = jst(jps[j], i);
+			if (s == S_DEAD || s == S_D) dead = 1;
+			if (s == S_U || s == S_BORROW) okdead = 0;
+			if (!jsame(p, jps[j], i)) bad = j;
+			j++;
+		}
+		lstate[i] = s0; lowner[i] = jow(p, i); lhome[i] = jhm(p, i);
+		if (bad < 0) {
+			if (empty(s0)) { j = 0; while (j < njps) { if (jst(jps[j], i) == S_DEAD) lstate[i] = S_DEAD; j++; } }
+		} else if (dead && okdead) lstate[i] = S_DEAD;
+		else if (fchk && !panic && !dry) {
+			errat(); puts(lname[i]); puts(": "); puts(what);
+			puts(" (one path leaves it "); puts(statename(s0)); puts(", another "); puts(statename(jst(jps[bad], i))); puts(")");
+			errend();
+		}
+		i++;
+	}
+	return 0;
+}
+// on path p: count (and with doit, emit) the frees for what the join made dead but p still owns
+fn fixups(p, n0, doit)
+{
+	let i = lbase, n = 0, s;
+	if (!fchk) return 0;
+	while (i < n0) {
+		s = jst(p, i);
+		if (lstate[i] == S_DEAD && (s == S_M || s == S_D)) { n++; if (doit) freevar(i); }
+		i++;
+	}
+	return n;
+}
+// a jump back to the top of a loop: whatever the loop owns has to be as it was
+fn backedge(s0)
+{
+	let p = R_SNAP + s0, i = p[0], e = p[1], s;
+	if (!fchk || !live) return 0;
+	if (e > nloc) e = nloc;
+	while (i < e) {
+		s = lstate[i];
+		if (empty(s) && empty(jst(p, i))) { if (jst(p, i) == S_DEAD) lstate[i] = S_DEAD; }
+		else if (s != jst(p, i) || lhome[i] != jhm(p, i) || (s == S_CHILD && lowner[i] != jow(p, i))) {
+			if (s == S_DEAD || s == S_D) cerrn(i, "is given away inside a loop that comes back around to it; give it away on a path that leaves the loop");
+			else if (!panic && !dry) {
+				errat(); puts(lname[i]); puts(": changes state inside a loop; each pass has to leave it as it found it (it went from ");
+				puts(statename(jst(p, i))); puts(" to "); puts(statename(s)); puts(")"); errend();
+			}
+		}
+		i++;
+	}
+	return 0;
+}
+// joins two paths that end at the same point, like the branches of if/else:
+// path a jumped (through the hole at ja) and path b falls through to here
+fn join2(sa, livea, ja, livebv, n0, what)
+{
+	let sb, nt, cj;
+	sb = snap_push();
+	njps = 0; if (livea) jadd(R_SNAP + sa); if (livebv) jadd(R_SNAP + sb);
+	join(n0, what);
+	if (livebv) fixups(R_SNAP + sb, n0, 1);
+	nt = 0; if (livea) nt = fixups(R_SNAP + sa, n0, 0);
+	if (nt) { cj = hole(); op(O_JMP); setlit(ja, here); fixups(R_SNAP + sa, n0, 1); setlit(cj, here); }
+	else setlit(ja, here);
+	live = livea || livebv;
+	return 0;
+}
+
+// ---- analyzer rules for the places values flow ----
+// recast: x as u / x as d / x as m
+fn recast(c, t)
+{
+	let i, st;
+	if (!fchk) return c;
+	if (c < C_VAR) { cerr("only a named owned object can be recast"); return c; }
+	i = c - C_VAR;
+	st = lstate[i];
+	lused[i] = 1;
+	if (st == S_CHILD) cerrn(i, "belongs to a container; recast the container instead");
+	else if (st == S_BORROW) cerrn(i, "is borrowed and can't be recast");
+	else if (st == S_PLAIN) cerrn(i, "isn't an owned object");
+	else if (st == S_DEAD) cerrn(i, "used after it was given away");
+	else if (t == S_M && st != S_M) cerrn(i, "can't be recast back to m");
+	else lstate[i] = t;
+	return c;
+}
+// an argument for a parameter tagged t (0 plain, 1 m, 2 d)
+fn argcheck(c, t)
+{
+	let i, st;
+	if (!fchk) return 0;
+	if (c == C_FRESH) { if (t != 2) cerr("a new object can only go straight to a d parameter; bind it to a name first"); return 0; }
+	if (c < C_VAR || !tracked(c - C_VAR)) return 0;
+	i = c - C_VAR;
+	st = lstate[i];
+	if (lstate[lroot(i)] == S_DEAD) { cerrn(i, "used after it was given away"); return 0; }
+	if (t <= 1) {	// untagged parameters are m: a lend
+		if (st == S_D) { cerrn(i, "is d; pass it to a d parameter (lending it would lose it)"); return 0; }
+		touch(i);
+		return 0;
+	}
+	if (st == S_D) { lstate[i] = S_DEAD; lused[i] = 1; return 0; }
+	if (st == S_M) cerrn(i, "is m; write d*x to give it away");
+	else if (st == S_U) cerrn(i, "is u; write d*x to give it away instead of returning it");
+	else if (st == S_CHILD) cerrn(i, "belongs to a container and can't be given away alone");
+	else cerrn(i, "is borrowed and can't be given away");
+	return 0;
+}
+fn emitown(p) { laddr(lslot[p]); op(O_LD); callname(s_own); return 0; }
+// a store of class rc into an lvalue of kind k (local or container index i)
+fn assigncheck(k, i, rc)
+{
+	let st, j, r, js;
+	if (!fchk) return C_PLAIN;
+	j = -1;
+	if (rc >= C_VAR && tracked(rc - C_VAR)) j = rc - C_VAR;
+	if (j >= 0 && lstate[lroot(j)] == S_DEAD) { cerrn(j, "used after it was given away"); return C_PLAIN; }
+	if (k == LV_LOCAL) {
+		st = lstate[i];
+		if (j < 0 && rc != C_FRESH) {
+			if (!empty(st)) cerrn(i, "still owns an object; overwriting it would leak it");
+			else lstate[i] = S_PLAIN;
+			return C_PLAIN;
+		}
+		if (!empty(st)) { cerrn(i, "still owns an object; overwriting it would leak it"); return C_PLAIN; }
+		if (rc == C_FRESH) { lstate[i] = S_M; lused[i] = 0; lown[i] = 1; if (ltag[i]) lstate[i] = ltag[i]; return C_PLAIN; }
+		js = lstate[j];
+		if (js == S_U && lhome[i] == lhome[j] - 1) {	// handing a u object up one block
+			lstate[i] = S_M; lused[i] = 0; lown[i] = 1; lstate[j] = S_DEAD; lused[j] = 1; if (ltag[i]) lstate[i] = ltag[i];
+			return C_PLAIN;
+		}
+		if (js == S_U) cerrn(j, "is u; it can only be handed to a variable of the enclosing block, or returned");
+		else cerrn(j, "is an owned object and can't be copied into another variable");
+		return C_PLAIN;
+	}
+	if (k == LV_ELEM) {
+		r = lroot(i);
+		st = lstate[r];
+		touch(i);
+		if (rc == C_FRESH) { emitown(i); return C_PLAIN; }
+		if (j < 0) return C_PLAIN;
+		js = lstate[j];
+		if (js == S_CHILD) cerrn(j, "already belongs to a container");
+		else if (js == S_BORROW) cerrn(j, "is borrowed and can't be stored");
+		else if (st == S_BORROW) {
+			if (js == S_U) cerrn(j, "is u; it has to leave through the block above, not into a borrowed object");
+			else { lstate[j] = S_DEAD; lused[j] = 1; emitown(i); }	// storing it gives it away
+		} else if (js != st) cerrn(j, "its tag doesn't match its container's (both have to be m, u or d)");
+		else if (lhome[j] < lhome[r]) cerrn(j, "lives in an outer block than the container it's stored into");
+		else { lstate[j] = S_CHILD; lowner[j] = i; lused[j] = 1; emitown(i); }
+		return C_PLAIN;
+	}
+	// a global, or memory the analyzer doesn't track: the collector takes it
+	if (j >= 0) {
+		if (lstate[j] == S_D) { lstate[j] = S_DEAD; lused[j] = 1; }
+		else cerrn(j, "must be d to be stored in a global or in untracked memory (the collector takes it over)");
+	}
+	return C_PLAIN;
+}
+fn retcheck(c)
+{
+	let i;
+	if (!fchk) return 0;
+	i = -1;
+	if (c >= C_VAR && tracked(c - C_VAR)) i = c - C_VAR;
+	if (i >= 0 && lstate[lroot(i)] == S_DEAD) { cerrn(i, "used after it was given away"); return 0; }
+	if (fret) {
+		if (i >= 0) {
+			if (lstate[i] == S_U) { lstate[i] = S_DEAD; lused[i] = 1; }
+			else cerrn(i, "has to be u to be returned; write 'return u*x'");
+		}
+		return 0;
+	}
+	if (c == C_FRESH) cerr("returns a new object; declare the function with -> .u");
+	else if (i >= 0) cerrn(i, "is owned and can't be returned from a function without -> .u");
+	return 0;
+}
+// the last expression of a block expression
+fn handup(c)
+{
+	let i;
+	if (!fchk) return C_PLAIN;
+	if (c == C_FRESH) return C_FRESH;
+	if (c < C_VAR || !tracked(c - C_VAR)) return C_PLAIN;
+	i = c - C_VAR;
+	if (lstate[i] == S_U && lhome[i] == fdepth) { lstate[i] = S_DEAD; lused[i] = 1; return C_FRESH; }
+	if (lstate[i] == S_U) cerrn(i, "only a u object of this block can be its value");
+	else cerrn(i, "has to be u to be handed up as the block's value");
+	return C_PLAIN;
+}
+fn discard(c)
+{
+	if (c == C_FRESH) cerr("a new object (or a u result) can't be thrown away");
+	else if (c >= C_VAR) touch(c - C_VAR);
+	return 0;
+}
+
+// ---- types ----
+// types are a compiler primitive: records in the type area, hash-consed so
+// the same type is always the same pointer and comparing types is comparing
+// words. untyped code is typed word, which goes with anything. the records
+// stay in memory after compiling, so programs can inspect them.
+//   t[0] kind  t[1] size in words  t[2] name  t[3] n  t[4] a  t[5] b  t[6] c  t[7..] extra
+//   ptr: a = element             arr: a = element, n = length
+//   fn: a = return type, n = parameter count, b = signature (u m d tags), extra = parameter types
+//   struct: n = field count (-1 until laid out), a = fields (name, type, offset),
+//           b = generic template, c = type arguments [n, t1, t2 ...]
+//   var: a type parameter, n = its index
+//   gen: a generic struct: n = parameter count, a = fields (name, type), b = field count, c = parameter names
+
+
+fn talloc(n) { let p = tytop; if (tytop + n >= R_TYEND) fatal("the type area is full"); tytop = tytop + n; wfill(p, 0, n); return p; }
+fn tnew(kind, size, nm, extra)
+{
+	let t = talloc(7 + extra);
+	t[0] = kind; t[1] = size; t[2] = nm;
+	if (ntl >= NTL) fatal("too many types");
+	R_TY[ntl] = t; ntl++;
+	return t;
+}
+fn tptr(e)
+{
+	let i = 0, t;
+	while (i < ntl) { t = R_TY[i]; if (t[0] == TY_PTR && t[4] == e) return t; i++; }
+	t = tnew(TY_PTR, 1, 0, 0); t[4] = e;
+	return t;
+}
+fn tarr(e, n)
+{
+	let i = 0, t;
+	while (i < ntl) { t = R_TY[i]; if (t[0] == TY_ARR && t[4] == e && t[3] == n) return t; i++; }
+	t = tnew(TY_ARR, n * tsz(e), 0, 0); t[4] = e; t[3] = n;
+	return t;
+}
+fn tfn(ret, np, ps, sig)
+{
+	let i = 0, j, t;
+	while (i < ntl) {
+		t = R_TY[i];
+		if (t[0] == TY_FN && t[4] == ret && t[3] == np && t[5] == sig) {
+			j = 0; while (j < np && t[7 + j] == ps[j]) j++;
+			if (j == np) return t;
+		}
+		i++;
+	}
+	t = tnew(TY_FN, 1, 0, np); t[4] = ret; t[3] = np; t[5] = sig;
+	wcopy(t + 7, ps, np);
+	return t;
+}
+fn tvar(i, nm)
+{
+	let k = 0, t;
+	while (k < ntl) { t = R_TY[k]; if (t[0] == TY_VAR && t[3] == i) return t; k++; }
+	t = tnew(TY_VAR, 1, nm, 0); t[3] = i;
+	return t;
+}
+fn tinst(g, args, n)
+{
+	let i = 0, j, t, v;
+	while (i < ntl) {
+		t = R_TY[i];
+		if (t[0] == TY_STRUCT && t[5] == g) {
+			v = t[6]; j = 0; while (j < n && v[1 + j] == args[j]) j++;
+			if (j == n) return t;
+		}
+		i++;
+	}
+	v = talloc(n + 1); v[0] = n; wcopy(v + 1, args, n);
+	t = tnew(TY_STRUCT, 0, g[2], 0); t[3] = -1; t[5] = g; t[6] = v;
+	return t;
+}
+// lay out a generic instance on first use
+fn tresolve(t)
+{
+	let g, f, n, i, fs, off = 0, ft, bs[8];
+	if (t[0] != TY_STRUCT || t[3] >= 0) return t;
+	if (t[3] == -2) { serr("a struct can't contain itself by value"); t[3] = 0; return t; }
+	t[3] = -2;
+	g = t[5]; n = g[5]; f = g[4];
+	wfill(bs, 0, 8); wcopy(bs, t[6] + 1, t[6][0]);
+	fs = talloc(n * 3 + 1);
+	i = 0;
+	while (i < n) {
+		ft = subst(f[i + i + 1], bs);
+		fs[i * 3] = f[i + i]; fs[i * 3 + 1] = ft; fs[i * 3 + 2] = off;
+		off = off + tsz(ft);
+		i++;
+	}
+	t[4] = fs; t[1] = off; t[3] = n;
+	return t;
+}
+fn tsz(t) { if (t[0] == TY_STRUCT && t[3] < 0) tresolve(t); return t[1]; }
+// replace type parameters with what they were bound to (unbound ones become word)
+fn subst(t, bs)
+{
+	let k = t[0], i, n, v[24], vec;
+	if (k == TY_VAR) { if (bs[t[3]]) return bs[t[3]]; return tword; }
+	if (k == TY_PTR) return tptr(subst(t[4], bs));
+	if (k == TY_ARR) return tarr(subst(t[4], bs), t[3]);
+	if (k == TY_FN) { n = t[3]; i = 0; while (i < n) { v[i] = subst(t[7 + i], bs); i++; } return tfn(subst(t[4], bs), n, v, t[5]); }
+	if (k == TY_STRUCT && t[5]) { vec = t[6]; n = vec[0]; i = 0; while (i < n) { v[i] = subst(vec[1 + i], bs); i++; } return tinst(t[5], v, n); }
+	return t;
+}
+fn isnum(t) { return t[0] == TY_INT || t[0] == TY_CHAR || t[0] == TY_BOOL; }
+fn isagg(t) { return t[0] == TY_ARR || t[0] == TY_STRUCT; }
+fn isptr(t) { return t[0] == TY_PTR || t[0] == TY_ARR; }
+fn decay(t) { if (t[0] == TY_ARR) return tptr(t[4]); return t; }
+fn telem(t) { if (t[0] == TY_PTR || t[0] == TY_ARR) return t[4]; return tword; }
+// can a value of type src go where dst is expected?
+fn compat(dst, src)
+{
+	if (dst == src || dst == tword || src == tword) return 1;
+	if (isnum(dst) && isnum(src)) return 1;
+	src = decay(src);
+	if (dst[0] == TY_PTR && src[0] == TY_PTR) {
+		if (dst[4] == tword || src[4] == tword || dst[4] == tvoid || src[4] == tvoid) return 1;
+		return dst[4] == src[4];
+	}
+	if ((dst[0] == TY_PTR || dst[0] == TY_FN) && xzero) return 1;	// a literal 0 is a null pointer
+	return dst == src;
+}
+fn unify(p, a, bs)
+{
+	let i, n, pv, av;
+	if (p[0] == TY_VAR) { i = p[3]; if (!bs[i]) { bs[i] = a; return 1; } return compat(bs[i], a); }
+	a = decay(a);
+	if (p[0] == TY_PTR && a[0] == TY_PTR) { if (a[4] == tword) return 1; return unify(p[4], a[4], bs); }
+	if (p[0] == TY_STRUCT && p[5] && a[0] == TY_STRUCT && a[5] == p[5]) {
+		pv = p[6]; av = a[6]; n = pv[0]; i = 0;
+		while (i < n) { if (!unify(pv[1 + i], av[1 + i], bs)) return 0; i++; }
+		return 1;
+	}
+	return compat(p, a);
+}
+fn tprint(t)
+{
+	let k = t[0], i, v;
+	if (k == TY_PTR) { putc('*'); return tprint(t[4]); }
+	if (k == TY_ARR) { putc('['); putn(t[3]); putc(']'); return tprint(t[4]); }
+	if (k == TY_FN) {
+		puts("fn(");
+		i = 0;
+		while (i < t[3]) {
+			if (i) puts(", ");
+			tprint(t[7 + i]);
+			if (i < 12 && tparamtag(t, i) == 1) puts(".m");
+			if (i < 12 && tparamtag(t, i) == 2) puts(".d");
+			i++;
+		}
+		putc(')');
+		if (t[4] != tword || (t[5] & 1)) { puts(" -> "); if (t[4] != tword) tprint(t[4]); if (t[5] & 1) puts(".u"); }
+		return 0;
+	}
+	if (t[2]) puts(t[2]); else puts("?");
+	if (k == TY_STRUCT && t[5]) {
+		v = t[6]; putc('<');
+		i = 0; while (i < v[0]) { if (i) puts(", "); tprint(v[1 + i]); i++; }
+		putc('>');
+	}
+	return 0;
+}
+fn tcerr(what, want, got)
+{
+	if (!tc_on || !live || dry || panic) return 0;
+	errat(); puts("type error: "); puts(what);
+	puts(": expected "); tprint(want); puts(", got "); tprint(got);
+	errend();
+	return 0;
+}
+fn tcneed(ok, what, got)
+{
+	if (ok || !tc_on || !live || dry || panic) return 0;
+	errat(); puts("type error: "); puts(what); puts(", got "); tprint(got);
+	errend();
+	return 0;
+}
+fn tpfind(n) { let i = ntp; while (i) { i--; if (tpn[i] == n) return i; } return -1; }
+fn istypename(n)
+{
+	let s;
+	if (tpfind(n) >= 0) return 1;
+	if (findloc(n) >= 0) return 0;
+	s = lookup(n);
+	return s >= 0 && skind[s] == K_TYPE;
+}
+// the closing > of a type argument list; splits >> in two
+fn closeangle()
+{
+	if (is_op(s_shr)) { tv = s_gt; return 0; }
+	expect(s_gt);
+	return 0;
+}
+fn ptype()
+{
+	let n, s, t, np = 0, ps[24], ret, args[8], na = 0, i;
+	if (accept(s_star)) return tptr(ptype());
+	if (accept(s_lk)) { n = cexpr(); expect(s_rk); t = ptype(); if (n < 0) serr("a negative array length"); return tarr(t, n); }
+	if (is_id(s_fn)) {
+		next(); expect(s_lp);
+		if (!is_op(s_rp)) { while (1) { if (np >= 24) die("too many parameters"); ps[np] = ptype(); np++; if (!accept(s_comma)) break; } }
+		expect(s_rp);
+		ret = tword;
+		i = 0;
+		if (accept(s_arrow)) { if (!is_op(s_dot)) ret = ptype(); if (accept(s_dot)) { if (!is_id(s_u)) die("the return tag is .u"); next(); i = 1; } }
+		return tfn(ret, np, ps, i + np + np);
+	}
+	if (tk != T_ID) { die("expected a type"); return tword; }
+	n = tv;
+	i = tpfind(n);
+	if (i >= 0) { next(); return tvar(i, n); }
+	s = lookup(n);
+	if (s < 0 || skind[s] != K_TYPE) { dien(n, "isn't a type"); return tword; }
+	next();
+	t = sval[s];
+	if (t[0] != TY_GEN) return t;
+	expect(s_lt);
+	while (1) {
+		if (na >= 8) die("too many type arguments");
+		args[na] = ptype();
+		if (tsz(args[na]) != 1) serr("type arguments have to be one word (a pointer, a number, or a parameter)");
+		na++;
+		if (!accept(s_comma)) break;
+	}
+	closeangle();
+	if (na != t[3]) serrn(n, "wrong number of type arguments");
+	return tinst(t, args, na);
+}
+// does a declaration start here? (a type, or a bare .tag)
+fn tstart()
+{
+	let k;
+	if (tk == T_OP) {
+		if (tv == s_lk || tv == s_dot) return 1;
+		if (tv == s_star) {	// *T name, **T name ...: look past the stars
+			k = 0;
+			while (k < 3) { peekat(k); if (!(pk_tk == T_OP && pk_tv == s_star)) break; k++; }
+			peekat(k);
+			return (pk_tk == T_ID && (istypename(pk_tv) || pk_tv == s_fn)) || (pk_tk == T_OP && pk_tv == s_lk);
+		}
+		return 0;
+	}
+	if (tk != T_ID) return 0;
+	return tv == s_fn || istypename(tv);
+}
+// [type] [.tag]
+fn dtype()
+{
+	dty = 0; dtag = 0;
+	if (!is_op(s_dot)) dty = ptype();
+	if (accept(s_dot)) {
+		if (tv == s_m) dtag = S_M; else if (tv == s_u) dtag = S_U; else if (tv == s_d) dtag = S_D; else die("a tag is .u, .m or .d");
+		next();
+	}
+	return 0;
+}
+// struct name { type field, ... }   or   struct name<A, B> { ... }
+fn kw_struct()
+{
+	let n, t, s, nf = 0, buf = R_QBUF, i, fs, off = 0, gen = 0, ft;
+	next();
+	n = name();
+	if (is_op(s_lt)) {	// generic
+		next(); ntp = 0;
+		while (1) { if (ntp >= 8) die("too many type parameters"); tpn[ntp] = name(); ntp++; if (!accept(s_comma)) break; }
+		closeangle();
+		gen = 1;
+		t = tnew(TY_GEN, 0, n, 0); t[3] = ntp;
+		fs = talloc(ntp); wcopy(fs, tpn, ntp); t[6] = fs;
+	} else { t = tnew(TY_STRUCT, 0, n, 0); t[3] = -2; }	// -2 while its fields are read
+	s = addsym(n, K_TYPE, t);
+	expect(s_lb);
+	while (!is_op(s_rb)) {
+		ft = ptype();
+		while (1) {
+			if (nf >= 1000) fatal("too many fields");
+			buf[nf + nf] = name(); buf[nf + nf + 1] = ft; nf++;
+			if (!accept(s_comma)) break;
+		}
+		expect(s_semi);
+	}
+	next();
+	if (gen) {
+		fs = talloc(nf + nf); wcopy(fs, buf, nf + nf);
+		t[4] = fs; t[5] = nf;
+		ntp = 0;
+	} else {
+		fs = talloc(nf * 3 + 1);
+		i = 0;
+		while (i < nf) {
+			ft = buf[i + i + 1];
+			if (ft == t) { serr("a struct can't contain itself by value; use a pointer"); ft = tword; }
+			fs[i * 3] = buf[i + i]; fs[i * 3 + 1] = ft; fs[i * 3 + 2] = off;
+			off = off + tsz(ft);
+			i++;
+		}
+		t[4] = fs; t[1] = off; t[3] = nf;
+	}
+	accept(s_semi);
+	return s;
+}
+// type name = T;
+fn kw_type() { let n; next(); n = name(); expect(s_eq); addsym(n, K_TYPE, ptype()); expect(s_semi); return 0; }
+// typecheck on; / typecheck off;
+fn kw_typecheck()
+{
+	next();
+	if (is_id(s_on)) tc_on = 1; else if (is_id(s_off)) tc_on = 0; else die("typecheck on or typecheck off");
+	next(); expect(s_semi);
+	return 0;
+}
+// the field of a struct type, or -1
+fn tfindfield(t, n) { let i = 0; tresolve(t); while (i < t[3]) { if (t[4][i * 3] == n) return i; i++; } return -1; }
+// sizeof(T or expr), typeof(T or expr): the expression form is compiled dry, so it never runs
+fn typearg()
+{
+	let t, sb, c;
+	expect(s_lp);
+	if (tstart() && !is_op(s_dot)) t = ptype();
+	else {
+		sb = snap_push(); dry++;
+		c = expr(); rval();
+		t = xty;
+		dry--; snap_restore(sb); snap_pop(sb);
+	}
+	expect(s_rp);
+	return t;
+}
+fn kw_sizeof() { let t; next(); t = typearg(); lit(tsz(t)); xty = tint; return 0; }
+fn kw_typeof() { let t; next(); t = typearg(); lit(t); xty = tword; return 0; }
+fn types_init()
+{
+	tytop = R_TY + NTL; ntl = 0;
+	tword = tnew(TY_WORD, 1, intern("word"), 0);
+	tint = tnew(TY_INT, 1, intern("int"), 0);
+	tchar = tnew(TY_CHAR, 1, intern("char"), 0);
+	tbool = tnew(TY_BOOL, 1, intern("bool"), 0);
+	tvoid = tnew(TY_VOID, 0, intern("void"), 0);
+	addsym(tword[2], K_TYPE, tword); addsym(tint[2], K_TYPE, tint); addsym(tchar[2], K_TYPE, tchar);
+	addsym(tbool[2], K_TYPE, tbool); addsym(tvoid[2], K_TYPE, tvoid);
+	s_lt = intern("<"); s_gt = intern(">"); s_shr = intern(">>"); s_le = intern("<="); s_ge = intern(">=");
+	s_eqeq = intern("=="); s_ne = intern("!="); s_plus = intern("+");
+	s_struct = intern("struct"); s_type = intern("type"); s_typecheck = intern("typecheck");
+	s_on = intern("on"); s_off = intern("off"); s_new = intern("new"); s_new_t = intern("new_t");
+	numops[0] = intern("*"); numops[1] = intern("/"); numops[2] = intern("%"); numops[3] = intern("&");
+	numops[4] = intern("|"); numops[5] = intern("^"); numops[6] = intern("<<"); numops[7] = s_shr; nnumops = 8;
+	return 0;
+}
+fn isnumop(o) { let i = 0; while (i < nnumops) { if (numops[i] == o) return 1; i++; } return 0; }
+// the type of a binary operation, checking it when the typechecker is on
+fn bintype(b, lt, rt)
+{
+	let o = bname[b];
+	lt = decay(lt); rt = decay(rt);
+	if (blen[b] < 0) { tcneed(!isagg(lt) && !isagg(rt), "&& and || need scalars", lt); return tbool; }
+	if (o == s_eqeq || o == s_ne) { if (!compat(lt, rt) && !compat(rt, lt)) tcerr("comparison", lt, rt); return tbool; }
+	if (o == s_lt || o == s_gt || o == s_le || o == s_ge) {
+		if (!(lt == tword || rt == tword || (isnum(lt) && isnum(rt)) || (lt[0] == TY_PTR && rt[0] == TY_PTR))) tcerr("comparison", lt, rt);
+		return tbool;
+	}
+	if (o == s_plus) {
+		if (lt[0] == TY_PTR && (isnum(rt) || rt == tword)) return lt;
+		if (rt[0] == TY_PTR && isnum(lt)) return rt;
+		if (lt == tword || rt == tword) return tword;
+		if (isnum(lt) && isnum(rt)) return tint;
+		tcerr("+", lt, rt); return tword;
+	}
+	if (o == s_minus) {
+		if (lt[0] == TY_PTR && rt[0] == TY_PTR) return tint;
+		if (lt[0] == TY_PTR && (isnum(rt) || rt == tword)) return lt;
+		if (lt == tword || rt == tword) return tword;
+		if (isnum(lt) && isnum(rt)) return tint;
+		tcerr("-", lt, rt); return tword;
+	}
+	if (isnumop(o)) {
+		if (lt == tword || rt == tword) return tword;
+		if (isnum(lt) && isnum(rt)) return tint;
+		if (isnum(lt)) lt = rt;
+		tcneed(0, "arithmetic needs numbers", lt); return tword;
+	}
+	return tword;	// operators a program added
+}
+
+// ---- reflection ----
+// for programs (and parse words) looking at types at runtime
+fn tkind(t) { return t[0]; }
+fn tsize(t) { return tsz(t); }
+fn tname(t) { return t[2]; }
+fn tlen(t) { return t[3]; }
+fn tnfields(t) { tresolve(t); return t[3]; }
+fn tfname(t, i) { tresolve(t); return t[4][i * 3]; }
+fn tftype(t, i) { tresolve(t); return t[4][i * 3 + 1]; }
+fn tfoff(t, i) { tresolve(t); return t[4][i * 3 + 2]; }
+fn tret(t) { return t[4]; }
+fn tnparams(t) { return t[3]; }
+fn tparam(t, i) { return t[7 + i]; }
+fn tparamtag(t, i) { return ((t[5] >> 6) >> (i + i)) & 3; }	// 0 untagged (m), 1 .m, 2 .d
+fn tretu(t) { return t[5] & 1; }
+fn tnargs(t) { if (t[0] != TY_STRUCT || !t[5]) return 0; return t[6][0]; }
+fn targ(t, i) { return t[6][1 + i]; }
+// the type of a function, by address. untyped functions get one made from their signature
+fn sigof(f)
+{
+	let i = nsym, s = -1, ws[24], n, k;
+	while (i) { i--; if (skind[i] == K_FN && sval[i] == f && (sflag[i] & F_DEF)) { s = i; break; } }
+	if (s < 0) return 0;
+	if (stype[s]) return stype[s];
+	n = (ssig[s] >> 1) & 31; k = 0;
+	while (k < n) { ws[k] = tword; k++; }
+	return tfn(tword, n, ws, ssig[s]);
+}
+fn sigofs(nm) { let s = lookups(nm); if (s < 0 || skind[s] != K_FN) return 0; return sigof(sval[s]); }
+
+// ---- expressions ----
+// every expression leaves its value on the stack, returns its analyzer class,
+// and sets xty to its type. lv means the stack holds an address that hasn't
+// been loaded yet; structs and arrays are never loaded, their address is
+// their value.
+fn rval() { if (lv) { if (!isagg(xty)) op(O_LD); lv = 0; } return 0; }
+fn kwcall(s, e)
+{
+	let f = sval[s], old = kw_expr, c;
+	kw_expr = e; xcls = C_PLAIN; xty = tword; xzero = 0;
+	f();
+	kw_expr = old;
+	c = xcls;
+	lv = 0; lvk = LV_NONE;
+	return c;
+}
+fn stmtonly() { if (kw_expr) serr("this can't be used inside an expression"); return 0; }
+// the arguments of a call. ft is the callee's type (or 0), bs the generic bindings
+fn args(tags, ft, bs)
+{
+	let np = 0, c, pt;
+	expect(s_lp);
+	if (!is_op(s_rp)) {
+		while (1) {
+			c = expr(); rval();
+			argcheck(c, (tags >> (np + np)) & 3);
+			if (ft && np < ft[3]) { pt = ft[7 + np]; if (!unify(pt, xty, bs)) tcerr("argument", subst(pt, bs), xty); }
+			np++;
+			if (!accept(s_comma)) break;
+		}
+	}
+	expect(s_rp);
+	return np;
+}
+// new(T) and new(T, count): a typed object, its type stamped into the header
+fn newtyped()
+{
+	let t, c;
+	t = ptype();
+	if (accept(s_comma)) {
+		c = expr(); rval(); plainuse(c);
+		if (tsz(t) != 1) { lit(tsz(t)); op(15); }
+		lit(tarr(t, 0));
+	} else { lit(tsz(t)); lit(t); }
+	expect(s_rp);
+	callname(s_new_t);
+	lv = 0; lvk = LV_NONE; xty = tptr(t); xzero = 0;
+	return C_FRESH;
+}
+fn call(s)
+{
+	let np, tags = 0, ret = 0, ft = stype[s], bs[8];
+	if (sname[s] == s_new && skind[s] == K_FN) {
+		peek();
+		if (pk_tk == T_OP && (pk_tv == s_star || pk_tv == s_lk)) { next(); return newtyped(); }
+		if (pk_tk == T_ID && (istypename(pk_tv) || pk_tv == s_fn)) { next(); return newtyped(); }
+	}
+	if (sflag[s] & F_SIG) { tags = ssig[s] >> 6; ret = ssig[s] & 1; }
+	else sflag[s] = sflag[s] | F_UNTYPED;
+	wfill(bs, 0, 8);
+	if (ngbind) { wcopy(bs, gbind, ngbind); ngbind = 0; }
+	np = args(tags, ft, bs);
+	if ((sflag[s] & F_SIG) && np != ((ssig[s] >> 1) & 31)) serrn(sname[s], "wrong number of arguments");
+	fnref(s); op(O_CALL);
+	lv = 0; lvk = LV_NONE; xzero = 0;
+	xty = tword;
+	if (ft) xty = subst(ft[4], bs);
+	if (ret) return C_FRESH;
+	return C_PLAIN;
+}
+// an enhancement used like a function: the arguments, then its one opcode
+fn enhcall(s)
+{
+	let nin = ssig[s] & 15, nout = (ssig[s] >> 4) & 15, n = 0, c;
+	expect(s_lp);
+	if (!is_op(s_rp)) { while (1) { c = expr(); rval(); plainuse(c); n++; if (!accept(s_comma)) break; } }
+	expect(s_rp);
+	if (n != nin) serrn(sname[s], "wrong number of inputs");
+	lv = 0; lvk = LV_NONE; xty = tword; xzero = 0;
+	if (sflag[s] & F_FALLBACK) { fnref(sfix[s] - 1); op(O_CALL); return C_PLAIN; }
+	op(XOP0 + sval[s]);
+	if (nout == 0) lit(0);
+	if (nout > 1) serrn(sname[s], "leaves several values; use it from asm");
+	return C_PLAIN;
+}
+fn primary()
+{
+	let n, i, s, c;
+	lv = 0; lvk = LV_NONE; xzero = 0;
+	if (tk == T_NUM) { lit(tv); xzero = tv == 0; xty = tint; next(); return C_PLAIN; }
+	if (tk == T_STR) { strlit(tv); next(); xty = tptr(tchar); return C_PLAIN; }
+	if (tk == T_OP) {
+		if (tv == s_lp) { next(); c = expr(); expect(s_rp); return c; }
+		if (tv == s_lb) return blockexpr();
+		die("expected an expression"); lit(0); xty = tword; return C_PLAIN;
+	}
+	if (tk != T_ID) { die("expected an expression"); lit(0); xty = tword; return C_PLAIN; }
+	n = tv;
+	i = findloc(n);
+	if (i >= 0) {
+		next();
+		if (!fchk && tracked(i)) serrn(n, "is tracked by the analyzer and can't be used in unchecked code");
+		laddr(lslot[i]);
+		xty = ltype[i];
+		if (larr[i]) return C_PLAIN;
+		lv = 1; lvk = LV_LOCAL; lvi = i;
+		if (tracked(i)) return C_VAR + i;
+		return C_PLAIN;
+	}
+	s = lookup(n);
+	if (s >= 0 && skind[s] == K_KW) {
+		if (!(sflag[s] & F_EXPR)) dien(n, "can't be used inside an expression");
+		return kwcall(s, 1);
+	}
+	if (s >= 0 && skind[s] == K_TYPE) { dien(n, "is a type, not a value"); lit(0); xty = tword; return C_PLAIN; }
+	next();
+	xty = tword;
+	if (s >= 0 && skind[s] == K_CONST) { lit(sval[s]); xty = tint; xzero = sval[s] == 0; return C_PLAIN; }
+	if (s >= 0 && skind[s] == K_GVAR) { lit(sval[s]); if (stype[s]) xty = stype[s]; lv = 1; lvk = LV_GLOBAL; return C_PLAIN; }
+	if (s >= 0 && skind[s] == K_GARR) { lit(sval[s]); if (stype[s]) xty = stype[s]; return C_PLAIN; }
+	if (s >= 0 && skind[s] == K_ENH) return enhcall(s);
+	if (s < 0) s = fwdfn(n);
+	if (is_op(s_lt) && (sflag[s] & F_GEN)) {	// f<int, *char>(...)
+		next(); ngbind = 0;
+		while (1) { if (ngbind >= 8) die("too many type arguments"); gbind[ngbind] = ptype(); ngbind++; if (!accept(s_comma)) break; }
+		closeangle();
+		if (!is_op(s_lp)) die("expected ( after the type arguments");
+	}
+	if (is_op(s_lp)) return call(s);
+	fnref(s);
+	if (stype[s]) xty = stype[s];
+	return C_PLAIN;
+}
+// ++ and -- on the address at the top of the stack
+fn incdec(post, dlt)
+{
+	if (!lv) die("++ and -- need something to assign to");
+	if (lvk == LV_LOCAL && fchk && tracked(lvi)) cerrn(lvi, "owns an object and can't be incremented");
+	tcneed(isnum(xty) || xty[0] == TY_PTR || xty == tword, "++ and -- need a number or a pointer", xty);
+	lv = 0; lvk = LV_NONE; xzero = 0;
+	lit(0); op(O_PICK); op(O_LD);
+	if (post) { lit(0); op(O_PICK); lit(dlt); op(O_ADD); lit(2); op(O_PICK); op(O_ST); }
+	else { lit(dlt); op(O_ADD); lit(0); op(O_PICK); lit(2); op(O_PICK); op(O_ST); }
+	op(O_SWAP); op(O_DROP);
+	return C_PLAIN;
+}
+// p.x and p->x: a field of a struct, or of the struct a pointer points at
+fn field(c)
+{
+	let n, st, i, b = -1;
+	next();
+	n = name();
+	rval();
+	if (c == C_FRESH) cerr("use a field of a new object only after binding it to a name");
+	else if (c >= C_VAR) { touch(c - C_VAR); b = c - C_VAR; }
+	st = xty;
+	if (st[0] == TY_PTR) st = st[4];
+	if (st[0] != TY_STRUCT) {
+		if (!panic && !dry) { errat(); putc('.'); puts(n); puts(": that's a "); tprint(xty); puts(", not a struct or a pointer to one"); errend(); }
+		xty = tword; lv = 1; lvk = LV_OTHER; return C_PLAIN;
+	}
+	i = tfindfield(st, n);
+	if (i < 0) {
+		if (!panic && !dry) { errat(); tprint(st); puts(" has no field "); puts(n); errend(); }
+		xty = tword; lv = 1; lvk = LV_OTHER; return C_PLAIN;
+	}
+	if (st[4][i * 3 + 2]) { lit(st[4][i * 3 + 2]); op(O_ADD); }
+	xty = st[4][i * 3 + 1];
+	lv = 1; xzero = 0;
+	if (b >= 0) { lvk = LV_ELEM; lvi = b; } else lvk = LV_OTHER;
+	return C_PLAIN;
+}
+fn postfix()
+{
+	let c = primary(), b, n, t, et, ft, bs[8];
+	while (1) {
+		if (tk == T_ID && tv == s_as) {	// e as T: same bits, another type
+			next(); t = ptype(); rval(); xty = t; lvk = LV_NONE;
+			continue;
+		}
+		if (tk != T_OP) return c;
+		if (tv == s_lk) {
+			next();
+			rval();
+			b = -1;
+			if (c == C_FRESH) cerr("index a new object only after binding it to a name");
+			else if (c >= C_VAR) { touch(c - C_VAR); b = c - C_VAR; }
+			tcneed(isptr(xty) || xty == tword, "only pointers and arrays can be indexed", xty);
+			et = telem(xty);
+			c = expr(); rval(); plainuse(c);
+			tcneed(isnum(xty) || xty == tword, "an index has to be a number", xty);
+			expect(s_rk);
+			if (tsz(et) != 1) { lit(tsz(et)); op(15); }
+			op(O_ADD);
+			lv = 1; xty = et; xzero = 0;
+			if (b >= 0) { lvk = LV_ELEM; lvi = b; } else lvk = LV_OTHER;
+			c = C_PLAIN;
+			continue;
+		}
+		if (tv == s_dot || tv == s_arrow) { c = field(c); continue; }
+		if (tv == s_lp) {	// call through a value
+			rval(); plainuse(c);
+			ft = 0;
+			if (xty[0] == TY_FN) ft = xty;
+			else tcneed(xty == tword, "only functions can be called", xty);
+			wfill(bs, 0, 8);
+			n = args(0, ft, bs);
+			lit(n); op(O_PICK); op(O_CALL); op(O_SWAP); op(O_DROP);
+			lv = 0; lvk = LV_NONE; c = C_PLAIN; xzero = 0;
+			xty = tword;
+			if (ft) xty = subst(ft[4], bs);
+			continue;
+		}
+		if (tv == s_inc) { next(); c = incdec(1, 1); continue; }
+		if (tv == s_dec) { next(); c = incdec(1, -1); continue; }
+		return c;
+	}
+	return c;
+}
+fn unary()
+{
+	let c, un, t;
+	if (tk == T_ID && (tv == s_u || tv == s_m || tv == s_d)) {	// u*x, d*x, m*x: recast
+		t = S_M; if (tv == s_u) t = S_U; if (tv == s_d) t = S_D;
+		next(); expect(s_star);
+		c = unary(); rval();
+		lvk = LV_NONE;
+		return recast(c, t);
+	}
+	if (tk == T_OP) {
+		if (tv == s_star) {
+			next(); c = unary(); rval(); plainuse(c);
+			tcneed(xty[0] == TY_PTR || xty == tword, "only pointers can be dereferenced", xty);
+			xty = telem(xty);
+			lv = 1; lvk = LV_OTHER; xzero = 0;
+			return C_PLAIN;
+		}
+		if (tv == s_amp) {
+			next(); c = unary();
+			if (!lv && !isagg(xty)) die("& needs something addressable");
+			if (c >= C_VAR) touch(c - C_VAR);
+			lv = 0; lvk = LV_NONE; xzero = 0;
+			xty = tptr(xty);
+			return C_PLAIN;
+		}
+		if (tv == s_inc) { next(); unary(); return incdec(0, 1); }
+		if (tv == s_dec) { next(); unary(); return incdec(0, -1); }
+		un = unfind(tv);
+		if (un >= 0) {
+			next(); c = unary(); rval(); plainuse(c);
+			emitseq(useq[un], ulen[un]);
+			if (un <= 1) xty = tbool;
+			else if (xty != tword) { tcneed(isnum(xty), "this operator needs a number", xty); xty = tint; }
+			lv = 0; lvk = LV_NONE; xzero = 0;
+			return C_PLAIN;
+		}
+	}
+	return postfix();
+}
+fn bin(minp)
+{
+	let c = unary(), b, p, a, j, lt;
+	while (tk == T_OP) {
+		b = binfind(tv);
+		if (b < 0) return c;
+		p = bprec[b];
+		if (p < minp) return c;
+		next(); rval(); plainuse(c);
+		lt = xty;
+		if (blen[b] == -1) {		// && : 0 if the left side is 0, else the right side as 0 or 1
+			a = hole(); op(O_JZ);
+			c = bin(p + 1); rval(); plainuse(c);
+			emitseq(useq[1], ulen[1]);	// !! normalizes
+			j = hole(); op(O_JMP);
+			setlit(a, here); lit(0); setlit(j, here);
+		} else if (blen[b] == -2) {	// || : 1 if the left side isn't 0, else the right side as 0 or 1
+			a = hole(); op(O_JZ);
+			lit(1); j = hole(); op(O_JMP);
+			setlit(a, here);
+			c = bin(p + 1); rval(); plainuse(c);
+			emitseq(useq[1], ulen[1]);
+			setlit(j, here);
+		} else {
+			c = bin(p + 1); rval(); plainuse(c);
+			emitseq(bseq[b], blen[b]);
+		}
+		xty = bintype(b, lt, xty);
+		lv = 0; lvk = LV_NONE; c = C_PLAIN; xzero = 0;
+	}
+	return c;
+}
+// [addr v] -> [v], storing v at addr
+fn storekeep() { op(O_SWAP); lit(1); op(O_PICK); op(O_SWAP); op(O_ST); return 0; }
+// c ? a : b
+fn ternary(c)
+{
+	let a, b, s0, sa, livea, live0 = live, n0 = nloc, ca, cb, ta;
+	rval(); plainuse(c);
+	next();
+	a = hole(); op(O_JZ);
+	s0 = snap_push();
+	ca = expr(); rval(); ta = xty;
+	if (ca != C_FRESH) plainuse(ca);
+	livea = live; sa = snap_push();
+	b = hole(); op(O_JMP);
+	expect(s_colon);
+	setlit(a, here);
+	snap_restore(s0); live = live0;
+	cb = expr(); rval();
+	if (cb != C_FRESH) plainuse(cb);
+	join2(sa, livea, b, live, n0, "ends the two sides of ?: in different states");
+	snap_pop(s0);
+	if (!compat(ta, xty) && !compat(xty, ta)) tcerr("the two sides of ?:", ta, xty);
+	if (ta != tword) xty = ta;
+	lv = 0; lvk = LV_NONE; xzero = 0;
+	if (ca == C_FRESH && cb == C_FRESH) return C_FRESH;
+	if (ca == C_FRESH || cb == C_FRESH) cerr("both sides of ?: have to be new objects, or neither");
+	return C_PLAIN;
+}
+fn expr()
+{
+	let c = bin(1), k, i, a, rc, lt;
+	if (tk != T_OP) return c;
+	if (tv == s_q) return ternary(c);
+	if (tv == s_eq) {
+		if (!lv) die("this can't be assigned to");
+		k = lvk; i = lvi; lt = xty;
+		if (isagg(lt)) serr("a whole struct or array can't be assigned; assign its fields");
+		next();
+		rc = expr(); rval();
+		if (!compat(lt, xty)) tcerr("assignment", lt, xty);
+		storekeep();
+		lv = 0; lvk = LV_NONE; xty = lt; xzero = 0;
+		return assigncheck(k, i, rc);
+	}
+	a = asgfind(tv);
+	if (a >= 0) {
+		if (!lv) die("this can't be assigned to");
+		if (lvk == LV_LOCAL && fchk && tracked(lvi)) cerrn(lvi, "owns an object; compound assignment would lose it");
+		lt = xty;
+		next();
+		lit(0); op(O_PICK); op(O_LD);
+		lv = 0;
+		rc = expr(); rval(); plainuse(rc);
+		emitseq(bseq[abin[a]], blen[abin[a]]);
+		k = bintype(abin[a], lt, xty);
+		if (!compat(lt, k)) tcerr("compound assignment", lt, k);
+		storekeep();
+		lv = 0; lvk = LV_NONE; xty = lt; xzero = 0;
+		return C_PLAIN;
+	}
+	return c;
+}
+// does the current token start a statement rather than an expression?
+fn stmtstart()
+{
+	let s;
+	if (tk == T_OP) return tv == s_semi || tv == s_lb || tstart();
+	if (tk != T_ID || findloc(tv) >= 0) return 0;
+	if (tstart()) return 1;
+	s = lookup(tv);
+	return s >= 0 && skind[s] == K_KW && !(sflag[s] & F_EXPR);
+}
+// { stmts; tail } as an expression: its value is the tail, or 0
+fn blockexpr()
+{
+	let save = nloc, c = C_PLAIN, tail = 0, t = tint;
+	next();
+	fdepth++; bxdepth++;
+	while (!is_op(s_rb)) {
+		if (tk == T_EOF) die("missing }");
+		if (stmtstart()) { stmt(); continue; }
+		c = expr(); rval();
+		if (accept(s_semi)) { op(O_DROP); discard(c); c = C_PLAIN; continue; }
+		if (!is_op(s_rb)) die("expected ; or } after an expression");
+		tail = 1; t = xty;
+	}
+	next();
+	if (tail) c = handup(c); else lit(0);
+	block_close(save);
+	fdepth--; bxdepth--;
+	lv = 0; lvk = LV_NONE; xty = t; xzero = 0;
+	return c;
+}
+
+// ---- constant expressions ----
+fn cprim()
+{
+	let v, s;
+	if (tk == T_NUM) { v = tv; next(); return v; }
+	if (accept(s_minus)) return 0 - cprim();
+	if (tk == T_OP && tv == uname[2]) { next(); return ~cprim(); }
+	if (accept(s_lp)) { v = cexpr(); expect(s_rp); return v; }
+	if (tk == T_ID) {
+		s = lookup(tv);
+		if (s >= 0 && (skind[s] == K_CONST || skind[s] == K_GARR || (skind[s] == K_FN && (sflag[s] & F_DEF)) || skind[s] == K_GVAR)) { next(); return sval[s]; }
+	}
+	die("expected a constant");
+	return 0;
+}
+fn cexpr()
+{
+	let v = cprim(), o;
+	while (tk == T_OP) {
+		o = tv;
+		if (o == bname[3]) { next(); v = v + cprim(); }
+		else if (o == bname[4]) { next(); v = v - cprim(); }
+		else if (o == bname[0]) { next(); v = v * cprim(); }
+		else if (o == bname[15]) { next(); v = v | cprim(); }
+		else if (o == bname[13]) { next(); v = v & cprim(); }
+		else if (o == bname[5]) { next(); v = v << cprim(); }
+		else if (o == bname[6]) { next(); v = v >> cprim(); }
+		else return v;
+	}
+	return v;
+}
+
+// ---- statements ----
+// after a syntax error: skip to the end of the statement
+fn resync()
+{
+	while (tk != T_EOF && !is_op(s_semi) && !is_op(s_rb)) next();
+	if (is_op(s_semi)) next();
+	panic = 0;
+	return 0;
+}
+fn stmt()
+{
+	let s, c;
+	if (panic) return resync();
+	if (tk == T_ID && findloc(tv) < 0) {
+		s = lookup(tv);
+		if (s >= 0 && skind[s] == K_KW && (sflag[s] & F_STMT)) { kwcall(s, 0); return 0; }
+	}
+	if (tstart()) { localdecl(1); return 0; }
+	if (tk == T_OP) {
+		if (tv == s_semi) { next(); return 0; }
+		if (tv == s_lb) { block(); return 0; }
+	}
+	c = expr(); rval(); op(O_DROP);
+	expect(s_semi);
+	discard(c);
+	return 0;
+}
+fn block()
+{
+	let save = nloc;
+	expect(s_lb);
+	fdepth++;
+	while (!is_op(s_rb)) { if (tk == T_EOF) die("missing }"); stmt(); }
+	block_close(save);	// before the }, so its line is the one reported
+	next();
+	fdepth--;
+	return 0;
+}
+// the body of if/while/for: its own block, even without braces
+fn substmt()
+{
+	let save = nloc;
+	if (is_op(s_lb)) return block();
+	fdepth++;
+	stmt();
+	block_close(save);
+	fdepth--;
+	return 0;
+}
+// let a = e, b[10];   or, typed:   int a = 1, b;   *node.m p = new(node);   .u r;
+// let infers pointer, struct and function types from the initializer and
+// keeps numbers as plain words.
+fn localdecl(typed)
+{
+	let n, i, c, k, t = 0, tg = 0;
+	if (typed) { dtype(); t = dty; tg = dtag; if (t == tvoid) serr("a variable can't be void"); }
+	while (1) {
+		n = name();
+		i = newloc(n);
+		ltag[i] = tg;
+		if (accept(s_lk)) {
+			k = cexpr(); expect(s_rk);
+			if (!t) t = tword;
+			larr[i] = 1; ltype[i] = tarr(t, k); fslots = fslots + tsz(ltype[i]);
+		} else if (t && isagg(t)) { larr[i] = 1; ltype[i] = t; fslots = fslots + tsz(t); }
+		else { fslots++; if (t) ltype[i] = t; }
+		if (accept(s_eq)) {
+			if (larr[i]) serr("an array or a struct can't be initialized with =");
+			c = expr(); rval(); laddr(lslot[i]); op(O_ST);
+			if (t) { if (!compat(t, xty)) tcerr("initializer", t, xty); }
+			else if (!isnum(xty)) ltype[i] = xty;
+			assigncheck(LV_LOCAL, i, c);
+		}
+		if (!accept(s_comma)) break;
+	}
+	expect(s_semi);
+	return 0;
+}
+fn kw_var() { stmtonly(); next(); return localdecl(0); }
+fn kw_if()
+{
+	let a, b, c, s0, sa, live0, livea, n0 = nloc, nt, cj;
+	stmtonly();
+	next();
+	expect(s_lp); c = expr(); rval(); plainuse(c); expect(s_rp);
+	a = hole(); op(O_JZ);
+	live0 = live;
+	s0 = snap_push();
+	substmt();
+	livea = live; sa = snap_push();
+	if (is_id(s_else)) {
+		next();
+		b = hole(); op(O_JMP);
+		setlit(a, here);
+		snap_restore(s0); live = live0;
+		substmt();
+		join2(sa, livea, b, live, n0, "ends the branches of an if in different states");
+	} else {
+		// the path that skips the then branch still has the states from before it
+		njps = 0; if (livea) jadd(R_SNAP + sa); if (live0) jadd(R_SNAP + s0);
+		join(n0, "ends the branches of an if in different states");
+		if (livea) fixups(R_SNAP + sa, n0, 1);
+		nt = 0; if (live0) nt = fixups(R_SNAP + s0, n0, 0);
+		if (nt) { cj = hole(); op(O_JMP); setlit(a, here); fixups(R_SNAP + s0, n0, 1); setlit(cj, here); }
+		else setlit(a, here);
+		live = livea || live0;
+	}
+	snap_pop(s0);
+	return 0;
+}
+// loop frame: 0 continue target  1 break chain  2 depth  3 snapshot  4 block-expression depth
+// loop frame: 0 continue target (-1 for a switch)  2 depth  3 snapshot at the top
+// 4 block-expression depth  5 locals at the start  6 its first exit record
+fn loop_push(cont, s0)
+{
+	let f = R_LOOP + lsp * 8;
+	if (lsp >= 60) fatal("loops nested too deeply");
+	f[0] = cont; f[1] = 0; f[2] = fdepth; f[3] = s0; f[4] = bxdepth; f[5] = nloc; f[6] = extop;
+	lsp++;
+	return 0;
+}
+// the end of a loop or switch: join its exits (the fall-out path sc through
+// the jump at a, if there is one, and every break) and lay out each path's
+// fixups on its way to the end
+fn loop_end(a, sc)
+{
+	let f, p, e, n0, outs = 0;
+	lsp--;
+	f = R_LOOP + lsp * 8;
+	n0 = f[5];
+	njps = 0;
+	if (sc >= 0) jadd(R_SNAP + sc);
+	p = R_EXIT + f[6]; e = R_EXIT + extop;
+	while (p < e) { jadd(p + 1); p = p + 3 + 3 * (p[2] - p[1]); }
+	join(n0, "leaves the loop in different states on different paths");
+	live = njps > 0;
+	p = R_EXIT + f[6];
+	while (p < e) {
+		if (fixups(p + 1, n0, 0)) { setlit(p[0], here); fixups(p + 1, n0, 1); outs = fixnew(hole(), outs); op(O_JMP); }
+		else outs = fixnew(p[0], outs);
+		p = p + 3 + 3 * (p[2] - p[1]);
+	}
+	if (a >= 0) setlit(a, here);
+	if (sc >= 0) fixups(R_SNAP + sc, n0, 1);
+	fixall(outs, here);
+	extop = f[6];
+	return 0;
+}
+fn kw_while()
+{
+	let c0 = here, a, s0, sc = -1, c, inf = 0;
+	stmtonly();
+	next();
+	s0 = snap_push();
+	expect(s_lp);
+	if (tk == T_NUM && tv) { peek(); if (pk_tk == T_OP && pk_tv == s_rp) inf = 1; }	// while (1): no way out but break
+	c = expr(); rval(); plainuse(c); expect(s_rp);
+	a = hole(); op(O_JZ);
+	if (!inf && live) sc = snap_push();
+	loop_push(c0, s0);
+	substmt();
+	backedge(s0);
+	jmp(c0);
+	loop_end(a, sc);
+	snap_pop(s0);
+	return 0;
+}
+fn kw_for()
+{
+	let save = nloc, s0, sc = -1, c0, a, b, st, c, inf = 0;
+	stmtonly();
+	next();
+	expect(s_lp);
+	fdepth++;
+	if (is_id(s_var)) kw_var();
+	else if (tstart()) localdecl(1);
+	else { if (!is_op(s_semi)) { c = expr(); rval(); op(O_DROP); discard(c); } expect(s_semi); }
+	s0 = snap_push();
+	c0 = here;
+	if (!is_op(s_semi)) {
+		if (tk == T_NUM && tv) { peek(); if (pk_tk == T_OP && pk_tv == s_semi) inf = 1; }
+		c = expr(); rval(); plainuse(c);
+	} else { lit(1); inf = 1; }
+	expect(s_semi);
+	a = hole(); op(O_JZ);
+	if (!inf && live) sc = snap_push();
+	b = hole(); op(O_JMP);
+	st = here;
+	if (!is_op(s_rp)) { c = expr(); rval(); op(O_DROP); discard(c); }
+	expect(s_rp);
+	jmp(c0);
+	setlit(b, here);
+	loop_push(st, s0);
+	substmt();
+	backedge(s0);
+	jmp(st);
+	loop_end(a, sc);
+	snap_pop(s0);
+	block_close(save);
+	fdepth--;
+	return 0;
+}
+fn kw_break()
+{
+	let f;
+	stmtonly();
+	next(); expect(s_semi);
+	if (lsp <= loopbase) { serr("break outside a loop or a switch"); return 0; }
+	f = R_LOOP + (lsp - 1) * 8;
+	if (f[4] != bxdepth) { serr("break can't leave a block expression"); return 0; }
+	exit_vars(f[2] + 1, 0);
+	if (live) exit_rec(hole()); else hole();
+	op(O_JMP);
+	live = 0;
+	return 0;
+}
+fn kw_continue()
+{
+	let j = lsp - 1, f;
+	stmtonly();
+	next(); expect(s_semi);
+	while (j >= loopbase && R_LOOP[j * 8] == -1) j--;	// past any switch
+	if (j < loopbase) { serr("continue outside a loop"); return 0; }
+	f = R_LOOP + j * 8;
+	if (f[4] != bxdepth) { serr("continue can't leave a block expression"); return 0; }
+	backedge(f[3]);
+	exit_vars(f[2] + 1, 0);
+	jmp(f[0]);
+	live = 0;
+	return 0;
+}
+// switch (e) { case 1, 2: ... case 'x': ... default: ... }
+// cases don't fall through: each one ends where the next begins, and break
+// leaves the switch early. case labels are constants.
+fn casebody(s0, live0)
+{
+	let save = nloc;
+	snap_restore(s0); live = live0;
+	fdepth++;
+	while (!is_op(s_rb) && !is_id(s_case) && !is_id(s_default)) { if (tk == T_EOF) { die("missing }"); break; } stmt(); }
+	block_close(save);
+	fdepth--;
+	if (live) { exit_rec(hole()); op(O_JMP); }	// the end of a case leaves the switch
+	live = 0;
+	return 0;
+}
+fn kw_switch()
+{
+	let save = nloc, tmp, c, s0, live0, defent = -1, skip, nxt, bj, v, a = -1;
+	stmtonly();
+	next();
+	expect(s_lp); c = expr(); rval(); plainuse(c); expect(s_rp);
+	fdepth++;
+	tmp = newloc(0); fslots++;	// a hidden local holds the value
+	laddr(lslot[tmp]); op(O_ST);
+	live0 = live;
+	s0 = snap_push();
+	loop_push(-1, s0);
+	expect(s_lb);
+	while (!is_op(s_rb)) {
+		if (tk == T_EOF) { die("missing }"); break; }
+		if (is_id(s_case)) {
+			next();
+			bj = 0;
+			while (1) {
+				v = cexpr();
+				laddr(lslot[tmp]); op(O_LD); lit(v); op(O_SUB);
+				bj = fixnew(hole(), bj); op(O_JZ);
+				if (!accept(s_comma)) break;
+			}
+			expect(s_colon);
+			nxt = hole(); op(O_JMP);
+			fixall(bj, here);
+			casebody(s0, live0);
+			setlit(nxt, here);
+		} else if (is_id(s_default)) {
+			next(); expect(s_colon);
+			if (defent >= 0) serr("a switch has one default");
+			skip = hole(); op(O_JMP);	// only reached when nothing matched
+			defent = here;
+			casebody(s0, live0);
+			setlit(skip, here);
+		} else die("expected case or default");
+	}
+	next();
+	snap_restore(s0); live = live0;
+	if (defent >= 0) { jmp(defent); loop_end(-1, -1); }
+	else { a = hole(); op(O_JMP); loop_end(a, s0); }	// nothing matched: out with the states from the top
+	snap_pop(s0);
+	block_close(save);
+	fdepth--;
+	return 0;
+}
+fn kw_return()
+{
+	let c;
+	stmtonly();
+	next();
+	if (!infn) serr("return outside a function");
+	if (bxdepth) serr("return can't leave a block expression");
+	if (is_op(s_semi)) { lit(0); c = C_PLAIN; }
+	else {
+		c = expr(); rval();
+		if (fty == tvoid) tcerr("return value", tvoid, xty);
+		else if (fty && !compat(fty, xty)) tcerr("return value", fty, xty);
+	}
+	expect(s_semi);
+	retcheck(c);
+	exit_vars(1, 0);
+	epichain = fixnew(here, epichain);
+	lit(MW - 1); op(O_JMP);
+	live = 0;
+	return 0;
+}
+fn kw_unchecked()
+{
+	let old = fchk;
+	stmtonly();
+	next();
+	fchk = 0;
+	substmt();
+	fchk = old;
+	return 0;
+}
+
+// ---- asm blocks: raw vm words, one per token ----
+// numbers push, -n pushes a negative number, #n emits a raw word, one-char
+// tokens from the mnemonic table are opcodes, names push the address of a
+// variable or function, :name defines a label for this block.
+fn asmblock()
+{
+	let nl = 0, nr = 0, i, k, c, s, ln = R_ASM, la = R_ASM + 64, rn = R_ASM + 128, ra = R_ASM + 384;
+	expect(s_lb);
+	while (!is_op(s_rb)) {
+		if (tk == T_EOF) die("unterminated asm block");
+		if (tk == T_NUM) { lit(tv); next(); continue; }
+		if (tk == T_STR) { strlit(tv); next(); continue; }
+		if (is_op(s_hash)) { next(); if (tk != T_NUM) die("# needs a number"); emit(tv); next(); continue; }
+		if (is_op(s_minus)) { next(); if (tk == T_NUM && tglue) { lit(0 - tv); next(); } else op(O_SUB); continue; }
+		if (is_op(s_colon)) { next(); if (nl >= 64) fatal("too many asm labels"); ln[nl] = name(); la[nl] = here; nl++; continue; }
+		if (tv[0] && !tv[1] && (c = mnemidx(tv[0])) >= 0) { op(c); next(); continue; }
+		if (tk != T_ID) die("bad token in asm");
+		i = findloc(tv);
+		if (i >= 0) { lused[i] = 1; laddr(lslot[i]); next(); continue; }
+		k = -1; i = 0;
+		while (i < nl) { if (ln[i] == tv) k = i; i++; }
+		if (k >= 0) { lit(la[k]); next(); continue; }
+		s = lookup(tv);
+		if (s >= 0 && skind[s] == K_ENH) { op(XOP0 + sval[s]); next(); continue; }
+		if (s >= 0 && skind[s] != K_FN && skind[s] != K_KW) { lit(sval[s]); next(); continue; }
+		if (s >= 0 && skind[s] == K_FN) { fnref(s); next(); continue; }
+		if (nr >= 250) fatal("too many asm label references");
+		rn[nr] = tv; ra[nr] = hole(); nr++; next();	// a label further down this block
+	}
+	next();
+	i = 0;
+	while (i < nr) {
+		k = -1; c = 0;
+		while (c < nl) { if (ln[c] == rn[i]) k = c; c++; }
+		if (k < 0) serrn(rn[i], "unknown name in asm");
+		setlit(ra[i], la[k]);
+		i++;
+	}
+	return 0;
+}
+fn kw_asm() { next(); asmblock(); xcls = C_PLAIN; return 0; }
+
+// ---- quote: code as data ----
+// a token list is an object: [n] then kind, value, line for each token. names,
+// strings and operators are interned pointers.
+fn grab() -> .u
+{
+	let n = 0, depth = 0, q;
+	if (!is_op(s_lb)) die("expected {");
+	next();
+	while (1) {
+		if (tk == T_EOF) die("unterminated quote");
+		if (is_op(s_lb)) depth++;
+		if (is_op(s_rb)) { if (!depth) break; depth--; }
+		if (n >= 2700) fatal("quote too long");
+		R_QBUF[n * 3] = tk; R_QBUF[n * 3 + 1] = tv; R_QBUF[n * 3 + 2] = tline; n++;
+		next();
+	}
+	next();
+	q = new(n * 3 + 1);
+	q[0] = n;
+	wcopy(q + 1, R_QBUF, n * 3);
+	return u*q;
+}
+unchecked fn qnew(src) -> .u { let n = src[0] * 3 + 1, q = new(n); wcopy(q, src, n); return q; }
+fn qdup(.m q) -> .u { let n = q[0] * 3 + 1, r = new(n); wcopy(r, q, n); return u*r; }
+fn wcopyto(.m q, n) { let i = 0; while (i < n) { emit(q[i]); i++; } return 0; }
+fn kw_quote()
+{
+	let q, j, a, n;
+	next();
+	q = grab();
+	j = hole(); op(O_JMP);
+	a = here;
+	n = q[0] * 3 + 1;
+	wcopyto(q, n);
+	free(d*q);
+	setlit(j, here);
+	lit(a);
+	callname(s_qnew);
+	xcls = C_FRESH;
+	return 0;
+}
+// tokens of a string, as a token list
+fn tokens(s) -> .u
+{
+	let n = 0, q;
+	src_push(2, s, 0, 0);
+	next();
+	while (tk != T_EOF) {
+		if (n >= 2700) fatal("too many tokens");
+		R_QBUF[n * 3] = tk; R_QBUF[n * 3 + 1] = tv; R_QBUF[n * 3 + 2] = tline; n++;
+		next();
+	}
+	src_pop();
+	q = new(n * 3 + 1);
+	q[0] = n;
+	wcopy(q + 1, R_QBUF, n * 3);
+	return u*q;
+}
+// feed a token list into the input: the parser reads it next, then carries
+// on where it was. the list is freed once it has been read.
+unchecked fn feed(.d q) { src_push(1, q, 1, 1); next(); return 0; }
+
+// ---- reading a unit and scanning it for signatures ----
+// a unit from stdin is read whole first (4 chars to a word), then scanned
+// once for fn signatures, so a function's tags are known before its first
+// call even when it's defined further down.
+unchecked fn readsrc()
+{
+	let cap = 4090, b = new(4090), n = 0, c, nb, w;
+	while (!eof()) {
+		c = getc() & 255;
+		if (c == 96) break;
+		if ((n >> 2) + 2 >= cap) { nb = new(cap + cap + 6); wcopy(nb, b, cap); free(b); b = nb; cap = cap + cap + 6; }
+		w = n >> 2;
+		if (!(n & 3)) b[w] = 0;
+		b[w] = b[w] | (c << ((n & 3) * 8));
+		n++;
+	}
+	b[n >> 2] = b[n >> 2] & (pow2[(n & 3) * 8] - 1);	// the 0 at the end
+	if ((n & 3) == 0) b[n >> 2] = 0;
+	b[(n >> 2) + 1] = 0;
+	return b;
+}
+// skip a <...> group (type parameters)
+fn pskipangle()
+{
+	let dp = 0;
+	while (tk != T_EOF) {
+		if (is_op(s_lt)) dp++;
+		else if (is_op(s_gt)) dp--;
+		else if (is_op(s_shr)) dp = dp - 2;
+		next();
+		if (dp <= 0) return 0;
+	}
+	return 0;
+}
+// at the name after fn: read the signature's tags and record them
+fn prescan_fn()
+{
+	let n = tv, np = 0, tags = 0, t = 0, ret = 0, dp, s;
+	if (tk != T_ID) return 0;
+	next();
+	if (is_op(s_lt)) pskipangle();
+	if (!is_op(s_lp)) return 0;
+	next();
+	if (!is_op(s_rp)) {
+		np = 1; dp = 1;
+		while (tk != T_EOF) {
+			if (is_op(s_lp)) dp++;
+			else if (is_op(s_rp)) { dp--; if (!dp) break; }
+			else if (dp == 1 && is_op(s_comma)) { if (np <= 12) tags = tags + (t << (np + np - 2)); np++; t = 0; }
+			else if (dp == 1 && is_op(s_dot)) { next(); if (is_id(s_m)) t = 1; else if (is_id(s_d)) t = 2; continue; }
+			next();
+		}
+		if (np <= 12) tags = tags + (t << (np + np - 2));
+	}
+	next();
+	if (accept(s_arrow)) {
+		while (tk != T_EOF && !is_op(s_lb) && !is_op(s_semi)) {
+			if (is_op(s_dot)) { next(); if (is_id(s_u)) ret = 1; continue; }
+			next();
+		}
+	}
+	s = lookup(n);
+	if (s < 0 || s < ubase || skind[s] != K_FN || (sflag[s] & F_DEF)) s = fwdfn(n);
+	if (!(sflag[s] & F_SIG)) { ssig[s] = ret + np + np + tags * 64; sflag[s] = sflag[s] | F_SIG | F_PRE; }
+	return 0;
+}
+fn prescan(kind, obj)
+{
+	let depth = 0, sp = panic, sn = nerr;
+	dry++;
+	src_push(kind, obj, 0, 0);
+	next();
+	while (tk != T_EOF) {
+		if (is_op(s_lb)) depth++;
+		else if (is_op(s_rb)) depth--;
+		else if (depth <= 0 && is_id(s_fn)) { next(); prescan_fn(); continue; }
+		next();
+	}
+	src_pop();
+	dry--; panic = sp; nerr = sn;
+	return 0;
+}
+// compile a whole unit from stdin
+fn unit_stdin()
+{
+	let src = readsrc();
+	prescan(3, src);
+	src_push(3, src, 0, 0);
+	next();
+	unit_top();
+	unit_end(ubase);
+	src_pop();
+	free(src);
+	return 0;
+}
+
+// ---- nested compiles ----
+// compile() and load() can run while another function is being compiled (from
+// a parse word). the function context is saved, the new code is emitted in
+// place with a jump around it, and then everything is put back.
+fn ctx_push()
+{
+	let f = R_CTX + ctxsp * 24;
+	if (ctxsp >= 30) fatal("compiles nested too deeply");
+	ctxsp++;
+	f[0] = nloc; f[1] = lbase; f[2] = fdepth; f[3] = fslots; f[4] = fchk; f[5] = fret; f[6] = live;
+	f[7] = bxdepth; f[8] = epichain; f[9] = fframe; f[10] = infn; f[11] = lsp; f[12] = loopbase;
+	f[13] = lv; f[14] = lvk; f[15] = lvi; f[16] = kw_expr; f[17] = xcls; f[18] = snaptop;
+	f[19] = fty; f[20] = ntp; f[21] = xty; wcopy(f + 22, tpn, 2);
+	return 0;
+}
+fn ctx_pop()
+{
+	let f;
+	ctxsp--;
+	f = R_CTX + ctxsp * 24;
+	nloc = f[0]; lbase = f[1]; fdepth = f[2]; fslots = f[3]; fchk = f[4]; fret = f[5]; live = f[6];
+	bxdepth = f[7]; epichain = f[8]; fframe = f[9]; infn = f[10]; lsp = f[11]; loopbase = f[12];
+	lv = f[13]; lvk = f[14]; lvi = f[15]; kw_expr = f[16]; xcls = f[17]; snaptop = f[18];
+	fty = f[19]; ntp = f[20]; xty = f[21]; wcopy(tpn, f + 22, 2);
+	return 0;
+}
+
+// ---- functions and the top level ----
+fn fn_begin(chk, ret)
+{
+	lbase = nloc; fdepth = 1; fslots = 0; fchk = chk && check_on; fret = ret; fty = 0;
+	live = 1; bxdepth = 0; epichain = 0; infn = 1; loopbase = lsp; lv = 0; lvk = LV_NONE;
+	return 0;
+}
+// fp -= frame size, then check the frame stack: past FBOT, reset fp and stop
+fn prologue()
+{
+	let k;
+	lit(ZFP); op(O_LD); fframe = hole(); op(O_SUB); lit(ZFP); op(O_ST);
+	lit(ZFP); op(O_LD); lit(FBOT); op(O_LT); k = hole(); op(O_JZ);
+	lit(FTOP); lit(ZFP); op(O_ST); callname(s_fovf);
+	setlit(k, here);
+	return 0;
+}
+fn epilogue()
+{
+	lit(0);
+	fixall(epichain, here);
+	lit(ZFP); op(O_LD); lit(fslots); op(O_ADD); lit(ZFP); op(O_ST); op(O_RET);
+	setlit(fframe, fslots);
+	infn = 0;
+	nloc = lbase;
+	return 0;
+}
+fn body()
+{
+	expect(s_lb);
+	while (!is_op(s_rb)) { if (tk == T_EOF) die("missing } at the end of a function"); stmt(); }
+	unused_check(lbase);
+	if (fchk && live) { exit_vars(1, 1); if (fret) cerr("a -> .u function has to end with a return"); }
+	next();
+	return 0;
+}
+// fn name<T>(int a, *node.m n, .d x, b) -> *list<T>.u { ... }
+fn fndef(chk)
+{
+	let n, s, np = 0, tags = 0, t, ret = 0, sig, i, pn[24], pt[24], pty[24], rty = 0, typed = 0, ft;
+	next();
+	n = name();
+	ntp = 0;
+	if (is_op(s_lt)) {	// type parameters
+		next();
+		while (1) { if (ntp >= 8) die("too many type parameters"); tpn[ntp] = name(); ntp++; if (!accept(s_comma)) break; }
+		closeangle();
+		typed = 1;
+	}
+	s = lookup(n);
+	if (s < 0 || s < ubase || skind[s] != K_FN || (sflag[s] & F_DEF)) { s = addsym(n, K_FN, 0); sflag[s] = 0; }
+	expect(s_lp);
+	if (!is_op(s_rp)) {
+		while (1) {
+			t = 0;
+			pty[np] = tword;
+			if (!is_op(s_dot) && ((tk == T_OP && (tv == s_star || tv == s_lk)) || (tk == T_ID && (tv == s_fn || istypename(tv))))) {
+				pty[np] = ptype(); typed = 1;
+				if (isagg(pty[np])) serr("structs and arrays are passed by pointer");
+			}
+			if (accept(s_dot)) {	// .m lends, .d takes over
+				if (tv == s_m) t = 1; else if (tv == s_d) t = 2; else die("a parameter tag is .m or .d");
+				next();
+			}
+			pn[np] = name();
+			if (np >= 12 && t) die("only the first 12 parameters can be tagged");
+			pt[np] = t;
+			if (np < 12) tags = tags + (t << (np + np));
+			np++;
+			if (np >= 24) die("too many parameters");
+			if (!accept(s_comma)) break;
+		}
+	}
+	expect(s_rp);
+	if (accept(s_arrow)) {
+		if (!is_op(s_dot)) { rty = ptype(); typed = 1; }
+		if (accept(s_dot)) { if (!is_id(s_u)) die("the return tag is .u"); next(); ret = 1; }
+	}
+	sig = ret + np + np + tags * 64;
+	if ((sflag[s] & F_SIG) && !(sflag[s] & F_PRE)) { if (ssig[s] != sig) serrn(n, "doesn't match its earlier declaration"); }
+	else if ((sflag[s] & F_UNTYPED) && (tags || ret)) serrn(n, "was called before its tags were declared; put a prototype above the first call");
+	ssig[s] = sig;
+	sflag[s] = (sflag[s] | F_SIG) - (sflag[s] & F_PRE);
+	if (ntp) sflag[s] = sflag[s] | F_GEN;
+	if (typed) {
+		if (!rty) rty = tword;
+		ft = tfn(rty, np, pty, sig);
+		if (stype[s] && stype[s] != ft) serrn(n, "doesn't match its earlier declaration");
+		stype[s] = ft;
+	}
+	if (accept(s_semi)) { ntp = 0; return s; }
+	if (sflag[s] & F_DEF) serrn(n, "is defined twice");
+	sval[s] = here;
+	sflag[s] = sflag[s] | F_DEF;
+	fixall(sfix[s], here); sfix[s] = 0;
+	fn_begin(chk, ret);
+	if (typed) fty = rty;
+	prologue();
+	i = 0;
+	while (i < np) {
+		t = newloc(pn[i]); fslots++;
+		ltype[t] = pty[i];
+		if (fchk && pt[i] == 1) lstate[t] = S_BORROW;
+		if (fchk && pt[i] == 2) { lstate[t] = S_M; lown[t] = 1; }
+		i++;
+	}
+	i = np;
+	while (i) { i--; laddr(i); op(O_ST); }
+	body();
+	epilogue();
+	ntp = 0;
+	return s;
+}
+// let g = 1, buf[10];   int g = 3;   [10]int buf;   point origin;
+fn gdecl(typed)
+{
+	let n, a, k, t = 0, s;
+	if (typed) { dtype(); t = dty; if (dtag) serr("tags go on locals and parameters, not globals"); if (t == tvoid) serr("a variable can't be void"); }
+	else next();
+	while (1) {
+		n = name();
+		if (accept(s_lk)) {
+			k = cexpr(); expect(s_rk);
+			s = addsym(n, K_GARR, here);
+			if (!t) t = tword;
+			stype[s] = tarr(t, k);
+			k = tsz(stype[s]);
+			while (k) { emit(0); k--; }
+		} else if (t && isagg(t)) {
+			s = addsym(n, K_GARR, here); stype[s] = t;
+			k = tsz(t);
+			while (k) { emit(0); k--; }
+		} else {
+			a = here;
+			s = addsym(n, K_GVAR, a);
+			if (t) stype[s] = t;
+			emit(0);
+			if (accept(s_eq)) {
+				if (tk == T_STR) { *(a + hdelta) = here; k = tv; while (*k) { emit(*k); k++; } emit(0); next(); }
+				else *(a + hdelta) = cexpr();
+			}
+		}
+		if (!accept(s_comma)) break;
+	}
+	expect(s_semi);
+	return 0;
+}
+fn gconst()
+{
+	let n;
+	next();
+	while (1) { n = name(); expect(s_eq); addsym(n, K_CONST, cexpr()); if (!accept(s_comma)) break; }
+	expect(s_semi);
+	return 0;
+}
+// enhance name(a, b) [-> n] micro "recipe" [else fn];
+// enhance name(a, b) [-> n] vm { asm } [else fn];
+// lays out the descriptor the install opcode reads, and wires it in right
+// away (an image wires its own in when it boots).
+fn enhdef()
+{
+	let n, np = 0, nout = 1, dsc, na, pay, len = 0, kind = 0, i, p, s, slot, r, pn[8];
+	next();
+	n = name();
+	expect(s_lp);
+	if (!is_op(s_rp)) { while (1) { if (np == 8) die("an enhancement takes at most 8 inputs"); pn[np] = name(); np++; if (!accept(s_comma)) break; } }
+	expect(s_rp);
+	if (accept(s_arrow)) { if (tk != T_NUM || tv < 0 || tv > 8) die("expected the number of outputs"); nout = tv; next(); }
+	dsc = here; i = 0; while (i < 7) { emit(0); i++; }
+	na = here; i = 0; while (i < np) { emit(0); i++; }
+	i = 0;
+	while (i < np) { *(na + i + hdelta) = here; p = pn[i]; while (*p) { emit(*p); p++; } emit(0); i++; }
+	if (accept(s_micro)) {
+		pay = here;
+		if (tk != T_STR) die("expected the recipe as a string");
+		while (tk == T_STR) { p = tv; while (*p) { emit(*p); p++; } next(); }
+		emit(0);
+	} else if (accept(s_vm)) { pay = here; asmblock(); op(O_RET); len = here - pay; kind = 1; }
+	else die("expected micro or vm");
+	slot = nenh;
+	if (slot >= 512) fatal("all 512 enhancement slots are taken");
+	nenh++;
+	p = dsc + hdelta;
+	p[0] = slot; p[1] = kind; p[2] = np; p[3] = nout; p[4] = pay; p[5] = len; p[6] = na;
+	s = addsym(n, K_ENH, slot);
+	ssig[s] = np + nout * 16 + dsc * 256;
+	if (accept(s_else)) { r = lookup(tv); if (r < 0) r = fwdfn(tv); next(); sfix[s] = r + 1; }
+	expect(s_semi);
+	if (!hdelta) {
+		r = install(dsc);
+		if (r < 0) {
+			if (!sfix[s]) serrn(n, "the enhancement didn't install (see install's codes in core.c)");
+			sflag[s] = sflag[s] | F_FALLBACK;
+		}
+	}
+	return 0;
+}
+// after a syntax error at the top level: skip to something that starts a declaration
+fn topsync()
+{
+	let depth = 0;
+	while (tk != T_EOF) {
+		if (is_op(s_lb)) depth++;
+		else if (is_op(s_rb)) { depth--; if (depth < 0) depth = 0; }
+		else if (!depth && tk == T_ID && (tv == s_fn || tv == s_var || tv == s_const || tv == s_struct || tv == s_type
+			|| tv == s_enhance || tv == s_typecheck || tv == s_unchecked || tv == s_immediate)) break;
+		next();
+	}
+	panic = 0;
+	return 0;
+}
+fn topitem()
+{
+	let chk = 1, imm = 0, s, k;
+	if (panic) return topsync();
+	if (is_id(s_unchecked)) {
+		next();
+		if (accept(s_semi)) { check_on = 0; return 0; }	// unchecked; switches the analyzer off from here on
+		chk = 0;
+	}
+	if (is_id(s_immediate)) { next(); imm = 1; }
+	if (is_id(s_fn)) {
+		s = fndef(chk);
+		if (imm) {
+			if (hdelta) serr("parse words can't be defined while building an image");
+			k = addsym(sname[s], K_KW, sval[s]);
+			sflag[k] = F_DEF | F_STMT | F_EXPR | F_TOP;
+		}
+		return 0;
+	}
+	if (!chk || imm) { die("expected fn"); return 0; }
+	if (is_id(s_var)) return gdecl(0);
+	if (is_id(s_struct)) { kw_struct(); return 0; }
+	if (is_id(s_type)) return kw_type();
+	if (is_id(s_typecheck)) return kw_typecheck();
+	if (is_id(s_enhance)) return enhdef();
+	if (is_id(s_const)) return gconst();
+	if (tk == T_ID) {
+		s = lookup(tv);
+		if (s >= 0 && skind[s] == K_KW && (sflag[s] & F_TOP)) { kwcall(s, 0); return 0; }
+	}
+	if (tstart()) return gdecl(1);
+	die("expected fn, let, const, struct, type or a declaration");
+	return 0;
+}
+fn unit_top() { while (tk != T_EOF) topitem(); return 0; }
+fn unit_end(from)
+{
+	let i = from;
+	panic = 0;
+	while (i < nsym) {
+		if (skind[i] == K_FN && !(sflag[i] & F_DEF) && sfix[i]) { tline = sval[i]; serrn(sname[i], "is used but never defined"); }
+		i++;
+	}
+	if (nerr) giveup();
+	return 0;
+}
+
+// compile a token list as the body of a new function, or (top) as top-level
+// declarations. returns the entry address of the function.
+unchecked fn compile_list(q, top)
+{
+	let hop = -1, entry = 0, from = nsym;
+	ctx_push();
+	if (infn) { hop = hole(); op(O_JMP); }
+	if (top) prescan(1, q);
+	src_push(1, q, 0, 0);
+	next();
+	if (top) unit_top();
+	else {
+		entry = here;
+		fn_begin(1, 0);
+		prologue();
+		while (tk != T_EOF) stmt();
+		unused_check(lbase);
+		if (fchk && live) exit_vars(1, 1);
+		epilogue();
+	}
+	src_pop();
+	unit_end(from);
+	if (hop >= 0) setlit(hop, here);
+	if (here > ptop) ptop = here;
+	ctx_pop();
+	return entry;
+}
+fn compile(q) { return compile_list(q, 0); }
+fn load(q) { compile_list(q, 1); return 0; }
+fn eval(q) { let f = compile_list(q, 0); return f(); }
+fn evals(s) { let q = tokens(s), r = eval(q); free(d*q); return r; }
+
+// ---- symbol blob ----
+// an image ends with its own symbol table so the genome knows its names:
+// kind, value, signature, name chars, 0 ... then a 0 kind.
+fn blob_emit(from)
+{
+	let i = from, p;
+	while (i < nsym) {
+		if ((skind[i] >= K_FN && skind[i] <= K_CONST) || skind[i] == K_ENH) {
+			emit(skind[i]); emit(sval[i]); emit(ssig[i]);
+			p = sname[i];
+			while (*p) { emit(*p); p++; }
+			emit(0);
+		}
+		i++;
+	}
+	emit(0);
+	return 0;
+}
+fn blob_load(p)
+{
+	let s, n;
+	while (*p) {
+		n = intern(p + 3);
+		s = addsym(n, p[0], p[1]);
+		ssig[s] = p[2];
+		sflag[s] = F_DEF | F_SIG;
+		if (p[0] == K_ENH) { if (p[1] >= nenh) nenh = p[1] + 1; install(p[2] >> 8); }
+		p = p + 3 + strlen(p + 3) + 1;
+	}
+	return 0;
+}
+// compile the rest of stdin as a genome image that will run at org, writing
+// it to dst. only the source's own names are visible while it compiles.
+// returns the image length in words.
+fn build_image(org, dst)
+{
+	let sh = here, sd = hdelta, sl = hlimit, sub = ubase, svl = vislo, sns = nsym, sen = nenh, n;
+	ubase = nsym; vislo = nsym; nenh = 0;
+	here = org; hdelta = dst - org; hlimit = org + 0x30000;
+	lit(FTOP); lit(ZFP); op(O_ST); fnref(fwdfn(s_start)); op(O_JMP); emit(0); emit(0);
+	unit_stdin();
+	*(dst + 5) = here;
+	blob_emit(ubase);
+	*(dst + 6) = here;
+	n = here - org;
+	popsyms(sns);
+	ubase = sub; vislo = svl; here = sh; hdelta = sd; hlimit = sl; nenh = sen;
+	return n;
+}
+
+// ---- setup ----
+fn gc_roots()
+{
+	markrange(0, ptop);
+	if (!hdelta && here > ptop) markrange(ptop, here);	// globals of a unit still compiling
+	markrange(GORG, GORG[6]);
+	markrange(R_SRC, R_SRC + 1024);
+	markrange(*ZFP, FTOP);
+	markrange(DSLO, DSHI);
+	return 0;
+}
+fn zc_init()
+{
+	pooltop = R_POOL;
+	wfill(R_IH, 0, IHN);
+	nsym = 0; nfixu = 0; fixfree = 0; nbin = 0; nun = 0; nasg = 0; nkop = 0; seqtop = 0;
+	lsp = 0; ctxsp = 0; snaptop = 0; nloc = 0; lbase = 0;
+	s_lp = intern("("); s_rp = intern(")"); s_lb = intern("{"); s_rb = intern("}");
+	s_lk = intern("["); s_rk = intern("]"); s_comma = intern(","); s_semi = intern(";");
+	s_eq = intern("="); s_arrow = intern("->"); s_inc = intern("++"); s_dec = intern("--");
+	s_star = intern("*"); s_amp = intern("&"); s_colon = intern(":"); s_hash = intern("#");
+	s_minus = intern("-"); s_dot = intern("."); s_q = intern("?"); s_case = intern("case"); s_default = intern("default"); s_andand = intern("&&"); s_oror = intern("||");
+	s_fn = intern("fn"); s_var = intern("let"); s_const = intern("const"); s_else = intern("else");
+	s_as = intern("as"); s_unchecked = intern("unchecked"); s_immediate = intern("immediate");
+	s_m = intern("m"); s_d = intern("d"); s_u = intern("u");
+	s_start = intern("start"); s_main = intern("main"); s_free = intern("free");
+	s_own = intern("own"); s_qnew = intern("qnew"); s_fovf = intern("frame_overflow");
+	s_enhance = intern("enhance"); s_micro = intern("micro"); s_vm = intern("vm");
+	return 0;
+}
+// operators and keywords. these are plain tables in memory: a program can
+// add operators, change precedences or replace keywords with its own.
+fn zc_tables()
+{
+	add_unop("!", "0 $ 0 ~ - | 31 > 1 +");	// index 0
+	add_unop("!!", "0 $ 0 ~ - | 31 > 0 ~ -");	// index 1: normalize to 0 or 1
+	add_unop("~", "-1 ^");				// index 2
+	add_unop("-", "0 ~ -");
+	add_binop("*", 10, "*");			// the first few indexes are used by cexpr
+	add_binop("/", 10, "idiv");			// native divide, wired in by rt.zc
+	add_binop("%", 10, "imod");
+	add_binop("+", 9, "+");				// 3
+	add_binop("-", 9, "-");				// 4
+	add_binop("<<", 8, "ishl");			// 5
+	add_binop(">>", 8, ">");			// 6
+	add_binop("<", 7, "<");
+	add_binop(">", 7, "~ <");
+	add_binop("<=", 7, "~ < 1 ^");
+	add_binop(">=", 7, "< 1 ^");
+	add_binop("==", 6, "- 0 $ 0 ~ - | 31 > 1 +");
+	add_binop("!=", 6, "- 0 $ 0 ~ - | 31 > 0 ~ -");
+	add_binop("&", 5, "&");				// 13
+	add_binop("^", 4, "^");
+	add_binop("|", 3, "|");				// 15
+	add_binop("&&", -1, 0);
+	add_binop("||", -2, 0);
+	addkop(s_eq); addkop(s_arrow); addkop(s_inc); addkop(s_dec);
+	add_kw("let", kw_var, F_STMT);
+	add_kw("if", kw_if, F_STMT);
+	add_kw("while", kw_while, F_STMT);
+	add_kw("for", kw_for, F_STMT);
+	add_kw("switch", kw_switch, F_STMT);
+	add_kw("break", kw_break, F_STMT);
+	add_kw("continue", kw_continue, F_STMT);
+	add_kw("return", kw_return, F_STMT);
+	add_kw("unchecked", kw_unchecked, F_STMT);
+	add_kw("asm", kw_asm, F_STMT | F_EXPR);
+	add_kw("quote", kw_quote, F_EXPR);
+	add_kw("sizeof", kw_sizeof, F_EXPR);
+	add_kw("typeof", kw_typeof, F_EXPR);
+	return 0;
+}
+fn start()
+{
+	let s, f;
+	heap_init();
+	zc_init();
+	blob_load(GORG[5]);
+	zc_tables();
+	types_init();
+	here = 0; hdelta = 0; hlimit = HEAP_LO; ptop = 0;
+	ubase = nsym; vislo = 0;
+	unit_stdin();
+	if (here > ptop) ptop = here;
+	s = lookup(s_main);
+	if (s >= 0 && skind[s] == K_FN && (sflag[s] & F_DEF)) { f = sval[s]; f(); }
+	halt();
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/src/rt.zc b/docs/history/13-gap-fixes/code/src/rt.zc
new file mode 100644
index 0000000..55b8976
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/src/rt.zc
@@ -0,0 +1,240 @@
+// ============================================================================
+// rt.zc: the runtime half of the genome. memory map, i/o, arithmetic helpers,
+// the heap (size-class free lists) and the mark-sweep collector.
+// ============================================================================
+
+// ---- memory map (words) ----
+const MW = 0x100000;		// 1m words of memory
+const HEAP_LO = 0x40000;	// heap: 0x40000 .. 0xA0000
+const HEAP_HI = 0xA0000;
+const ZFP = 0xA0000;		// frame pointer word, used by every prologue
+const GORG = 0xC0000;		// the genome (this code) lives here
+const FBOT = 0xE0000;		// frame stack: FBOT .. FTOP, grows down
+const FTOP = 0xF0000;
+const RS0 = 0xF0000;		// return stack grows up from here
+const MARK0 = 0xF8000;		// mark stack for the collector
+const MARKN = 0x4000;
+const DSLO = 0xFC000;		// data stack: DSLO .. MW-16, grows down
+const DSHI = 0xFFFF0;
+const MAGIC = 0x2B7E1516;
+
+// ---- virtual enhancements ----
+// install(desc) wires a custom opcode into the cpu (the % opcode). these three
+// give the language native division and left shift (zdiv, zmod and zshl
+// below are the same thing done in software). they come first, since the
+// compiler resolves / % and << to them by name.
+fn install(desc) { return asm { desc @ % }; }
+enhance idiv(a, b) micro "a = sdiv a b";
+enhance imod(a, b) micro "a = srem a b";
+enhance ishl(a, b) micro "a = shl a b";
+
+// ---- i/o ----
+fn putc(ch) { asm { ch @ . } return 0; }
+fn getc() { return asm { , }; }
+fn eof() { return asm { ? }; }
+fn halt() { asm { q } return 0; }
+fn puts(s) { let i = 0; while (s[i]) { putc(s[i]); i++; } return 0; }
+fn putn(n)
+{
+	let b[12], i = 0;
+	if (n < 0) { putc('-'); n = 0 - n; }
+	if (n < 0) { puts("2147483648"); return 0; }
+	while (1) { b[i++] = '0' + n % 10; n = n / 10; if (!n) break; }
+	while (i) putc(b[--i]);
+	return 0;
+}
+fn strlen(s) { let n = 0; while (s[n]) n++; return n; }
+fn streq(a, b) { let i = 0; while (a[i] && a[i] == b[i]) i++; return a[i] == b[i]; }
+fn wcopy(dst, src, n) { let i = 0; while (i < n) { dst[i] = src[i]; i++; } return 0; }
+fn wfill(dst, v, n) { let i = 0; while (i < n) { dst[i] = v; i++; } return 0; }
+
+// ---- arithmetic the hardware doesn't have ----
+let pow2[32];
+let zrem;
+fn zudiv(n, dv)
+{
+	let q = 0, r = 0, i = 30;
+	if (n < dv) { zrem = n; return 0; }
+	while (i >= 0) {
+		r = r + r + ((n >> i) & 1);
+		q = q + q;
+		if (r >= dv) { r = r - dv; q++; }
+		i--;
+	}
+	zrem = r;
+	return q;
+}
+fn zdiv(a, b)
+{
+	let s = 0, q;
+	if (b == 0) { zrem = a; return 0; }
+	if (a < 0) { a = 0 - a; s = 1; }
+	if (b < 0) { b = 0 - b; s = s ^ 1; }
+	q = zudiv(a, b);
+	if (s) return 0 - q;
+	return q;
+}
+fn zmod(a, b) { let neg = a < 0; if (b == 0) return a; zdiv(a, b); if (neg) return 0 - zrem; return zrem; }
+fn zshl(a, b) { return a * pow2[b & 31]; }
+
+// ---- heap ----
+// a buddy allocator. the heap is cut into aligned power-of-two chunks, every
+// block is a power of two words, and a freed block merges with its buddy
+// (the other half of the block they were split from) whenever that one is
+// free too, so freed space can be reused at any size. every block has a 6
+// word header before the pointer the program sees:
+//   p[-6] block size   p[-5] size class   p[-4] flags (0 free, 1 live, 3 marked)
+//   p[-3] p ^ MAGIC    p[-2] owner (the container that owns it, or 0)
+//   p[-1] its type (a type record from new(T), or 0 from new(n))
+// free blocks sit on a doubly linked list per class, linked through p[0], p[1].
+const HDR = 6;
+let hbump, freel[32], gc_runs, gc_freed, gc_auto = 1;
+
+// the size of the top-level chunk holding heap offset off
+fn topsize(off)
+{
+	let h = HEAP_HI - HEAP_LO, base = 0, sz;
+	while (h) {
+		sz = 1;
+		while (sz + sz <= h) sz = sz + sz;
+		if (off < base + sz) return sz;
+		base = base + sz; h = h - sz;
+	}
+	return 0;
+}
+fn fpush(b, k) { b[2] = 0; b[6] = freel[k]; b[7] = 0; if (freel[k]) freel[k][7] = b; freel[k] = b; return 0; }
+fn funlink(b, k)
+{
+	if (b[7]) b[7][6] = b[6]; else freel[k] = b[6];
+	if (b[6]) b[6][7] = b[7];
+	return 0;
+}
+fn mkblock(b, k) { b[0] = pow2[k]; b[1] = k; b[2] = 0; b[3] = 0; b[4] = 0; b[5] = 0; return b; }
+fn heap_init()
+{
+	let i = 1, b = HEAP_LO, sz, k;
+	pow2[0] = 1;
+	while (i < 32) { pow2[i] = pow2[i - 1] + pow2[i - 1]; i++; }
+	hbump = HEAP_HI;
+	wfill(freel, 0, 32);
+	while (b < HEAP_HI) {
+		sz = topsize(b - HEAP_LO); k = 0;
+		while (pow2[k] < sz) k++;
+		fpush(mkblock(b, k), k);
+		b = b + sz;
+	}
+	return 0;
+}
+// a free block of class k, split down from a bigger one if needed; 0 if none
+fn balloc(k)
+{
+	let j = k, b, h;
+	while (j < 32 && !freel[j]) j++;
+	if (j >= 32) return 0;
+	b = freel[j];
+	funlink(b, j);
+	while (j > k) { j--; h = b + pow2[j]; fpush(mkblock(h, j), j); }
+	mkblock(b, k);
+	return b;
+}
+let fend;		// end of the block bfree last made, for the sweep
+// put block b back, merging it with its buddy as long as it can
+fn bfree(b)
+{
+	let k = b[1], sz = pow2[k], off, bud;
+	while (1) {
+		off = b - HEAP_LO;
+		if (sz >= topsize(off)) break;
+		bud = HEAP_LO + (off ^ sz);
+		if (bud[2] != 0 || bud[1] != k || bud[0] != sz) break;
+		funlink(bud, k);
+		if (bud < b) { b[0] = 0; b[3] = 0; b = bud; }	// the upper header is inside the merged block now
+		else { bud[0] = 0; bud[3] = 0; }
+		k++; sz = sz + sz;
+		mkblock(b, k);
+	}
+	fpush(mkblock(b, k), k);
+	fend = b + sz;
+	return 0;
+}
+fn isobj(x) { return x >= HEAP_LO + HDR && x < hbump && x[-3] == (x ^ MAGIC) && (x[-4] & 1); }
+
+// every prologue checks the frame stack; on overflow it resets the frame
+// pointer (so this can run at all) and stops
+fn frame_overflow() { puts("zy: frame stack overflow\n"); halt(); return 0; }
+fn oom() { puts("zc: out of heap memory\n"); halt(); return 0; }
+// n words typed t
+unchecked fn new_t(n, t) -> .u
+{
+	let need = n + HDR, k = 3, b, p;
+	if (n < 0) need = HDR;
+	while (pow2[k] < need) k++;
+	b = balloc(k);
+	if (!b && gc_auto) { gc(); b = balloc(k); }
+	if (!b) oom();
+	p = b + HDR;
+	b[2] = 1; b[3] = p ^ MAGIC; b[4] = 0; b[5] = t;
+	wfill(p, 0, pow2[k] - HDR);
+	return p;
+}
+unchecked fn new(n) -> .u { return new_t(n, 0); }
+fn osize(p) { if (!isobj(p)) return 0; return p[-6] - HDR; }
+fn typeof_obj(p) { if (!isobj(p)) return 0; return p[-1]; }
+
+// frees p and, recursively, every object p owns
+fn release(p)
+{
+	let b = p - HDR, n = b[0] - HDR, i = 0, w;
+	b[2] = 0;
+	while (i < n) { w = p[i]; if (isobj(w) && w[-2] == p) release(w); i++; }
+	bfree(b);
+	return 0;
+}
+unchecked fn free(.d p) { if (isobj(p)) release(p); return 0; }
+fn own(c, p) { if (isobj(c)) c[-2] = p; return c; }
+
+// ---- mark-sweep ----
+// conservative and non-moving. roots: the program area (globals live
+// between functions), the genome's globals, the compiler's input stack,
+// the live part of the frame stack and the whole data stack region.
+let ms_top, ms_over, gc_lo, gc_hi;
+fn mark(w)
+{
+	if (!isobj(w) || (w[-4] & 2)) return 0;
+	w[-4] = w[-4] | 2;
+	if (ms_top < MARKN) { MARK0[ms_top] = w; ms_top++; } else ms_over = 1;
+	return 0;
+}
+fn markrange(a, b) { while (a < b) { mark(*a); a++; } return 0; }
+fn drain()
+{
+	let p;
+	while (ms_top) { ms_top--; p = MARK0[ms_top]; markrange(p, p + p[-6] - HDR); }
+	return 0;
+}
+fn gc_roots();
+unchecked fn gc()
+{
+	let b, sz, n = 0;
+	ms_top = 0; ms_over = 0;
+	gc_roots();
+	drain();
+	while (ms_over) {	// the mark stack overflowed: rescan marked objects
+		ms_over = 0;
+		b = HEAP_LO;
+		while (b < HEAP_HI) { if (b[2] == 3) markrange(b + HDR, b + b[0]); b = b + b[0]; drain(); }
+	}
+	b = HEAP_LO;
+	while (b < HEAP_HI) {
+		sz = b[0];
+		if (b[2] == 1) { bfree(b); n++; b = fend; }	// merging may swallow what follows
+		else { if (b[2] == 3) b[2] = 1; b = b + sz; }
+	}
+	gc_runs++;
+	gc_freed = gc_freed + n;
+	return n;
+}
+// number of live objects, for tests
+fn live_objects() { let b = HEAP_LO, n = 0; while (b < HEAP_HI) { if (b[2] & 1) n++; b = b + b[0]; } return n; }
+// the biggest block that's free right now, in words
+fn largest_free() { let k = 31; while (k > 0 && !freel[k]) k--; if (!freel[k]) return 0; return pow2[k]; }
diff --git a/docs/history/13-gap-fixes/code/test.sh b/docs/history/13-gap-fixes/code/test.sh
new file mode 100755
index 0000000..e28182d
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/test.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+# full check: bootstraps the compiler from zc0, verifies the fixpoint, then runs
+# the examples and tests on the portable interpreter (host), the arm64 jit under
+# qemu, and the llvm backend. needs gcc; the jit half needs aarch64-linux-gnu-gcc
+# and qemu-aarch64, the llvm half needs llvm-config and libLLVM (each is skipped
+# if missing).
+cd "$(dirname "$0")"; T=$(mktemp -d); trap 'rm -rf $T' EXIT
+ok=0; bad=0
+chk(){ if [ "$1" = "$2" ]; then echo "ok   $3"; ok=$((ok+1)); else echo "FAIL $3: got [$1]"; bad=$((bad+1)); fi; }
+src(){ cat src/rt.zc src/compiler.zc; }
+selfc(){ (cat tools/build.zc; printf '`'; src) | $1 > $2; }
+
+# bootstrap: zc0 (c) -> g0, g0 compiles compiler.zc -> g1, g1 compiles it -> g2
+gcc -O1 -w zc0.c -o $T/zc0 && gcc -O1 -w mkgenome.c -o $T/mkg || exit 1
+mkdir $T/s0 $T/s1
+cp core.c io_linux.c $T/s0/; cp core.c io_linux.c $T/s1/
+src | $T/zc0 > $T/s0/genome.h || exit 1
+gcc -O2 -w -DJTYPE=int $T/s0/core.c $T/s0/io_linux.c -o $T/zy0
+selfc $T/zy0 $T/g1.bin; $T/mkg < $T/g1.bin > $T/s1/genome.h
+gcc -O2 -w -DJTYPE=int $T/s1/core.c $T/s1/io_linux.c -o $T/zy1
+selfc $T/zy1 $T/g2.bin
+cmp -s $T/g1.bin $T/g2.bin && chk 1 1 "fixpoint: the compiler compiles itself to the same $(($(stat -c %s $T/g1.bin) / 4)) words" || chk 0 1 "fixpoint"
+cmp -s $T/s1/genome.h genome.h && chk 1 1 "genome.h is up to date" || chk 0 1 "genome.h is stale (cp the bootstrap output over it)"
+
+run(){	# $1 = vm command, $2 = label
+	local vm="$1" l="$2"
+	chk "$($vm < examples/hello.zc)" "hello, world!" "$l hello"
+	chk "$($vm < examples/fact.zc | tr '\n' '/')" "1101110101111100000000/3628800/" "$l factorial"
+	chk "$( (cat examples/echo.zc; printf '`abc\n') | $vm)" "abc" "$l echo after the backtick"
+	chk "$($vm < examples/selfpatch.zc)" "ABC" "$l self-patching code"
+	chk "$($vm < examples/lists.zc | tr '\n' '/')" "[0 1 4 9 16 25]/live: 7/after the block: 0/" "$l ownership frees everything"
+	chk "$( (cat examples/repl.zc; printf '`fn sq(x) { return x * x; }`putn(sq(7)); putc(10);`puts("hi\\n");') | $vm | tr '\n' '/')" "49/hi/" "$l repl on the resident compiler"
+	chk "$($vm < examples/typed.zc | tr '\n' '/')" "last: 4/point is 2 words: x int, y int/vec<*point> is 3 words: len int, cap int, items **point/push is fn(*vec<T>, T.d) -> bool/the heap says v is a vec<T>, and v.items[0] is a point/" "$l typed example"
+	chk "$($vm < examples/wiring.zc)" "16 1234 25 4/9" "$l enhancement example"
+	chk "$($vm < tests/basics.zc | tr '\n' '/')" "285 610 42 512/hey 65 -3 -2 1024 -8/12456/757/9 100-101/5/ok/" "$l language basics"
+	chk "$($vm < tests/umd.zc)" "100 6 0 15 99 5 5" "$l u m d lifetimes"
+	chk "$($vm < tests/gc.zc)" "1000 1 900 1 199900" "$l mark-sweep collector"
+	chk "$($vm < tests/meta.zc | tr '\n' '/')" "1024 19/unless ok/rrr/15 42/7/42/7/144/" "$l parse words, quote, eval, load, operator tables"
+	chk "$($vm < tests/misc.zc | tr '\n' '/')" "45/54321/ok/" "$l compile-time eval, patched mnemonics, unchecked"
+	chk "$($vm < tests/types.zc | tr '\n' '/')" "12 5 2 15 56 42 7 14 3/rect *rect *list<int> fn(int) -> *list<T>.u fn(*list<T>) -> T fn(word.d)/a:point@0 b:point@2 tag:int@4 /point 1 1/" "$l types, generics, reflection"
+	chk "$($vm < tests/typeok.zc)" "14" "$l a program the typechecker accepts"
+	chk "$($vm < tests/typeoff.zc)" "6" "$l the typechecker is off by default"
+	chk "$($vm < tests/enhance.zc)" "100 0 343 3,2 5 -2 0" "$l virtual enhancements"
+	chk "$($vm < tests/joins.zc)" "0 0 5 80 8 3 9 0" "$l joins free what one path gave away; switch, ?:, no prototypes"
+	chk "$($vm < tests/buddy.zc)" "131072 262144 1 0" "$l buddy allocator merges freed blocks"
+	chk "$($vm < tests/borrowmove.zc)" "6" "$l storing into a borrowed object moves it"
+	chk "$($vm < tests/manyerrors.zc | tr '\n' '/')" "zc: line 3: expected an expression/zc: line 4: x: m object is never used/zc: line 5: type error: initializer: expected *char, got int/zc: line 6: expected ;/zc: 4 errors/" "$l several errors in one run"
+	chk "$($vm < tests/overflow_return.zc 2>&1)" "zy: return stack overflow" "$l return stack overflow is caught"
+	chk "$($vm < tests/overflow_data.zc 2>&1)" "zy: data stack overflow" "$l data stack overflow is caught"
+	chk "$($vm < tests/overflow_frame.zc 2>&1)" "zy: frame stack overflow" "$l frame stack overflow is caught"
+	local r; r=$(tests/runerr.sh "$vm" tests/errors | tail -1)
+	chk "$r" "rejected: $(ls tests/errors/*.zc | wc -l) passed, 0 failed" "$l analyzer rejects every bad program"
+	r=$(tests/runerr.sh "$vm" tests/typeerrors | tail -1)
+	chk "$r" "rejected: $(ls tests/typeerrors/*.zc | wc -l) passed, 0 failed" "$l typechecker rejects every bad program"
+}
+gcc -O2 -w -DJTYPE=int core.c io_linux.c -o $T/zy
+run $T/zy "interp"
+if command -v aarch64-linux-gnu-gcc >/dev/null && command -v qemu-aarch64 >/dev/null; then
+	aarch64-linux-gnu-gcc -O2 -w -DJTYPE=int -static core.c io_linux.c -o $T/zyj || exit 1
+	printf '#!/bin/sh\nexec qemu-aarch64 %s "$@"\n' $T/zyj > $T/jit; chmod +x $T/jit
+	run $T/jit "jit"
+	selfc $T/jit $T/gj.bin; cmp -s $T/g1.bin $T/gj.bin && chk 1 1 "jit self-compile matches" || chk 0 1 "jit self-compile matches"
+else echo "skip jit (no aarch64 toolchain or qemu)"; fi
+if command -v llvm-config >/dev/null; then
+	gcc -O2 -w -DJTYPE=int -DZYLLVM $(llvm-config --cflags) core.c io_linux.c -o $T/zyl $(llvm-config --ldflags --libs) || exit 1
+	run $T/zyl "llvm"
+	printf '#!/bin/sh\nZYHOT=1 exec %s "$@"\n' $T/zyl > $T/llall; chmod +x $T/llall
+	chk "$($T/llall < tests/types.zc | md5sum)" "$($T/zy < tests/types.zc | md5sum)" "llvm compiling every block agrees"
+	selfc $T/zyl $T/gl.bin; cmp -s $T/g1.bin $T/gl.bin && chk 1 1 "llvm self-compile matches" || chk 0 1 "llvm self-compile matches"
+else echo "skip llvm (no llvm-config)"; fi
+echo "$ok passed, $bad failed"; [ $bad = 0 ]
diff --git a/docs/history/13-gap-fixes/code/tests/basics.zc b/docs/history/13-gap-fixes/code/tests/basics.zc
new file mode 100644
index 0000000..c1f1faf
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/basics.zc
@@ -0,0 +1,22 @@
+let table[10];
+let greeting = "hey";
+const N = 10, BIG = 0x100 * 2;
+fn fib(n) { if (n < 2) return n; return fib(n - 1) + fib(n - 2); }
+fn twice(f, x) { return f(f(x)); }
+fn inc(x) { return x + 1; }
+fn main()
+{
+	let i, s = 0, a[5];
+	for (i = 0; i < N; i++) table[i] = i * i;
+	for (let j = 0; j < N; j++) s += table[j];
+	putn(s); putc(' '); putn(fib(15)); putc(' '); putn(twice(inc, 40)); putc(' '); putn(BIG); putc(10);
+	puts(greeting); putc(' '); putn('A'); putc(' '); putn(-17 / 5); putc(' '); putn(-17 % 5); putc(' '); putn(1 << 10); putc(' '); putn(-64 >> 3); putc(10);
+	i = 0; while (1) { i++; if (i == 3) continue; if (i > 6) break; putn(i); } putc(10);
+	a[0] = 5; a[1] = a[0]++; a[2] = ++a[0]; putn(a[0]); putn(a[1]); putn(a[2]); putc(10);
+	let b = { let t = 3; t * t };
+	putn(b); putc(' '); putn(3 > 2 && 2 > 1); putn(0 || 0); putn(!5); putn(~0); putn(5 != 5); putn(4 >= 4); putc(10);
+	let x = asm { 2 3 + };
+	putn(x); putc(10);
+	asm { 'o' . 'k' . 10 . }
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/borrowmove.zc b/docs/history/13-gap-fixes/code/tests/borrowmove.zc
new file mode 100644
index 0000000..43f27b2
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/borrowmove.zc
@@ -0,0 +1,2 @@
+fn put(.m box, int v) { *int c = new(int); *c = v; box[0] = c; return 0; }
+fn main() { let b = new(1); put(b, 6); putn(*(b[0] as *int)); putc(10); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/buddy.zc b/docs/history/13-gap-fixes/code/tests/buddy.zc
new file mode 100644
index 0000000..2000598
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/buddy.zc
@@ -0,0 +1,15 @@
+// the buddy allocator: 20000 small blocks, freed, merge back into one big one
+let keep[20000];
+fn main()
+{
+	let i = 0, p;
+	while (i < 20000) { keep[i] = new(2); i++; }   // 20000 8-word blocks
+	putn(largest_free()); putc(' ');
+	i = 0; while (i < 20000) { free(keep[i]); i++; }
+	putn(largest_free()); putc(' ');
+	p = new(200000);	// only possible if the small blocks merged back
+	putn(osize(p) >= 200000); putc(' ');
+	free(d*p);
+	putn(live_objects()); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/enhance.zc b/docs/history/13-gap-fixes/code/tests/enhance.zc
new file mode 100644
index 0000000..6acc742
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/enhance.zc
@@ -0,0 +1,29 @@
+// custom opcodes: recipes, lifted vm code, several outputs, and a fallback
+enhance clampadd(a, b) micro "a = add a b; a = min a 100; a = max a 0";
+enhance cube(x) vm { 0 $ 0 $ * * };
+enhance divmod(a, b) -> 2 micro "r2 = sdiv a b" "\n r1 = srem a b\n r0 = r2";
+enhance div7(a) micro "a = sdiv a 7";
+enhance urem10(a) micro "a = urem a 10";
+enhance hi(a, b) micro "a = mulhu a b";
+enhance noisy(x) vm { 0 $ . } else soft_noisy;	// i/o can't be lifted, so calls use the fallback
+fn soft_noisy(x) { return x + 1; }
+let qq, rr, seed = 7;
+fn rnd() { seed = seed * 1103515245 + 12345; return seed ^ (seed >> 11); }
+fn main()
+{
+	let i = 0, a, bad = 0;
+	putn(clampadd(70, 50)); putc(' '); putn(clampadd(-50, 2)); putc(' '); putn(cube(7)); putc(' ');
+	asm { 17 5 divmod rr ! qq ! }
+	putn(qq); putc(','); putn(rr); putc(' ');
+	putn(noisy(4)); putc(' ');
+	putn(hi(-1, -1)); putc(' ');
+	while (i < 5000) {
+		a = rnd();
+		if (div7(a) != zdiv(a, 7)) bad++;
+		if (urem10(a) < 0 || urem10(a) > 9) bad++;
+		if (a / (i + 1) != zdiv(a, i + 1)) bad++;
+		i++;
+	}
+	putn(bad); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/errors/back_to_m.zc b/docs/history/13-gap-fixes/code/tests/errors/back_to_m.zc
new file mode 100644
index 0000000..b8c160f
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/back_to_m.zc
@@ -0,0 +1,2 @@
+// expect: x: can't be recast back to m
+fn main() { let x = new(3); d*x; m*x; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/borrow_escape.zc b/docs/history/13-gap-fixes/code/tests/errors/borrow_escape.zc
new file mode 100644
index 0000000..ce24480
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/borrow_escape.zc
@@ -0,0 +1,3 @@
+// expect: p: is owned and can't be returned
+fn f(.m p) { return p; }
+fn main() { let x = new(1); f(x); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/branch_mismatch.zc b/docs/history/13-gap-fixes/code/tests/errors/branch_mismatch.zc
new file mode 100644
index 0000000..bd19968
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/branch_mismatch.zc
@@ -0,0 +1,3 @@
+// expect: x: ends the branches of an if in different states
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(1); if (x[0]) take(d*x); else u*x; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/child_dies.zc b/docs/history/13-gap-fixes/code/tests/errors/child_dies.zc
new file mode 100644
index 0000000..67caca9
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/child_dies.zc
@@ -0,0 +1,3 @@
+// expect: c: used after it was given away
+fn take(.d p) { return p[0]; }
+fn main() { let p = new(2), c = new(1); p[0] = c; take(d*p); return c[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/child_recast.zc b/docs/history/13-gap-fixes/code/tests/errors/child_recast.zc
new file mode 100644
index 0000000..c9ccd62
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/child_recast.zc
@@ -0,0 +1,2 @@
+// expect: c: belongs to a container; recast the container instead
+fn main() { let p = new(2), c = new(1); p[0] = c; d*c; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/copy_owned.zc b/docs/history/13-gap-fixes/code/tests/errors/copy_owned.zc
new file mode 100644
index 0000000..862c7ef
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/copy_owned.zc
@@ -0,0 +1,2 @@
+// expect: x: is an owned object and can't be copied
+fn main() { let x = new(1); let y = x; return y[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/d_into_block.zc b/docs/history/13-gap-fixes/code/tests/errors/d_into_block.zc
new file mode 100644
index 0000000..2d7f526
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/d_into_block.zc
@@ -0,0 +1,2 @@
+// expect: x: used after it was given away
+fn main() { let x = new(1); d*x; { x[0] = 5; } return x[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/d_kept.zc b/docs/history/13-gap-fixes/code/tests/errors/d_kept.zc
new file mode 100644
index 0000000..dcbfb86
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/d_kept.zc
@@ -0,0 +1,2 @@
+// expect: x: d object was never given away
+fn main() { let x = new(3); d*x; x[0] = 1; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/discard_u.zc b/docs/history/13-gap-fixes/code/tests/errors/discard_u.zc
new file mode 100644
index 0000000..dd76e94
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/discard_u.zc
@@ -0,0 +1,3 @@
+// expect: can't be thrown away
+fn mk() -> .u { let p = new(1); return u*p; }
+fn main() { mk(); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/give_m.zc b/docs/history/13-gap-fixes/code/tests/errors/give_m.zc
new file mode 100644
index 0000000..cd67896
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/give_m.zc
@@ -0,0 +1,3 @@
+// expect: x: is m; write d*x
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); take(x); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/global_store.zc b/docs/history/13-gap-fixes/code/tests/errors/global_store.zc
new file mode 100644
index 0000000..dc0e546
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/global_store.zc
@@ -0,0 +1,3 @@
+// expect: x: must be d to be stored in a global
+let g;
+fn main() { let x = new(1); g = x; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/leak_overwrite.zc b/docs/history/13-gap-fixes/code/tests/errors/leak_overwrite.zc
new file mode 100644
index 0000000..d19b5fd
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/leak_overwrite.zc
@@ -0,0 +1,2 @@
+// expect: x: still owns an object
+fn main() { let x = new(1); x = new(2); return x[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/lend_d.zc b/docs/history/13-gap-fixes/code/tests/errors/lend_d.zc
new file mode 100644
index 0000000..55ac7e0
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/lend_d.zc
@@ -0,0 +1,4 @@
+// expect: x: is d; pass it to a d parameter
+fn look(.m p) { return p[0]; }
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); d*x; look(x); take(x); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/loop_move.zc b/docs/history/13-gap-fixes/code/tests/errors/loop_move.zc
new file mode 100644
index 0000000..df3c94a
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/loop_move.zc
@@ -0,0 +1,3 @@
+// expect: x: is given away inside a loop that comes back around to it
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(1); let i = 0; d*x; while (i < 3) { take(x); i++; } return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/plain_return.zc b/docs/history/13-gap-fixes/code/tests/errors/plain_return.zc
new file mode 100644
index 0000000..4540714
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/plain_return.zc
@@ -0,0 +1,3 @@
+// expect: returns a new object; declare the function with -> .u
+fn mk() { return new(1); }
+fn main() { return mk(); }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/return_m.zc b/docs/history/13-gap-fixes/code/tests/errors/return_m.zc
new file mode 100644
index 0000000..1acc4be
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/return_m.zc
@@ -0,0 +1,3 @@
+// expect: x: has to be u to be returned
+fn mk() -> .u { let x = new(1); return x; }
+fn main() { let y = mk(); return y[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/tag_mismatch.zc b/docs/history/13-gap-fixes/code/tests/errors/tag_mismatch.zc
new file mode 100644
index 0000000..079f249
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/tag_mismatch.zc
@@ -0,0 +1,2 @@
+// expect: c: its tag doesn't match its container's
+fn main() { let p = new(2), c = new(1); u*p; p[0] = c; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/u_dropped.zc b/docs/history/13-gap-fixes/code/tests/errors/u_dropped.zc
new file mode 100644
index 0000000..e1ca68a
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/u_dropped.zc
@@ -0,0 +1,2 @@
+// expect: x: u object must leave this block
+fn main() { let x = new(3); u*x; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/u_skip_level.zc b/docs/history/13-gap-fixes/code/tests/errors/u_skip_level.zc
new file mode 100644
index 0000000..6caeeb3
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/u_skip_level.zc
@@ -0,0 +1,2 @@
+// expect: t: is u; it can only be handed to a variable of the enclosing block
+fn main() { let r; { { let t = new(1); u*t; r = t; } } return r[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/unchecked_touch.zc b/docs/history/13-gap-fixes/code/tests/errors/unchecked_touch.zc
new file mode 100644
index 0000000..141639d
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/unchecked_touch.zc
@@ -0,0 +1,2 @@
+// expect: x: is tracked by the analyzer and can't be used in unchecked code
+fn main() { let x = new(1); unchecked { x[0] = 1; } return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/unused.zc b/docs/history/13-gap-fixes/code/tests/errors/unused.zc
new file mode 100644
index 0000000..64aff1f
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/unused.zc
@@ -0,0 +1,2 @@
+// expect: x: m object is never used
+fn main() { let x = new(3); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/errors/use_after_give.zc b/docs/history/13-gap-fixes/code/tests/errors/use_after_give.zc
new file mode 100644
index 0000000..8a10922
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/errors/use_after_give.zc
@@ -0,0 +1,3 @@
+// expect: x: used after it was given away
+fn take(.d p) { return p[0]; }
+fn main() { let x = new(3); take(d*x); return x[0]; }
diff --git a/docs/history/13-gap-fixes/code/tests/gc.zc b/docs/history/13-gap-fixes/code/tests/gc.zc
new file mode 100644
index 0000000..41f14a0
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/gc.zc
@@ -0,0 +1,20 @@
+let keep;
+unchecked fn churn(n)
+{
+	let i = 0, p;
+	while (i < n) { p = new(10); p[0] = i; if (i % 100 == 0) keep = p; i++; }
+	return 0;
+}
+fn main()
+{
+	let base = live_objects(), f;
+	churn(1000);
+	putn(live_objects() - base); putc(' ');
+	f = gc();
+	putn(f >= 990); putc(' ');		// conservative: a stale word or two may keep one alive
+	putn(keep[0]); putc(' ');		// the one a global still points at survives
+	churn(200000);				// 3.2m words through a 393k word heap: needs the automatic collector
+	putn(gc_runs > 1); putc(' ');
+	putn(keep[0]); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/joins.zc b/docs/history/13-gap-fixes/code/tests/joins.zc
new file mode 100644
index 0000000..a272e08
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/joins.zc
@@ -0,0 +1,32 @@
+// joins: something given away on one path is dead afterwards, and the paths
+// that still own it free it on the way in. nothing here leaks.
+fn take(.d p) { return p[0]; }
+fn later(.d p);	// not needed any more, but still allowed
+fn mk(int v) -> *int.u { *int p = new(int); *p = v; return u*p; }
+fn count(int n) { let s = 0; switch (n % 4) { case 0: s = 10; case 1, 2: s = 20; break; default: s = 30; } return s; }
+fn main()
+{
+	let base = live_objects(), i = 0, hits = 0, k;
+	while (i < 50) {
+		let x = mk(i);
+		if (i % 3 == 0) take(d*x);	// else: freed here by the fixup
+		i++;
+	}
+	putn(live_objects() - base); putc(' ');
+	// give away and break: fine now; the normal exit frees it
+	i = 0;
+	let y = mk(7);
+	while (i < 10) { if (i == 4) { take(d*y); break; } i++; }
+	putn(live_objects() - base); putc(' ');
+	let z = mk(5);
+	while (1) { if (z[0] == 5) { hits = take(d*z); break; } }
+	putn(hits); putc(' ');
+	putn(count(0) + count(1) + count(2) + count(3)); putc(' ');
+	k = i > 3 ? i * 2 : 0 - 1;
+	putn(k); putc(' ');
+	putn(forward(new(int))); putc(' ');	// tagged and defined below: the prescan knows .d
+	**int pp; *int q = new(int); *q = 9; pp = &q; putn(**pp); free(d*q); putc(' ');
+	putn(live_objects() - base); putc(10);
+	return 0;
+}
+fn forward(*int.d p) { return 3 + *p; }
diff --git a/docs/history/13-gap-fixes/code/tests/manyerrors.zc b/docs/history/13-gap-fixes/code/tests/manyerrors.zc
new file mode 100644
index 0000000..7c9febf
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/manyerrors.zc
@@ -0,0 +1,6 @@
+// several errors in one run: a syntax error, an analyzer error, a type error
+typecheck on;
+fn f() { let a = ; return 0; }
+fn g() { let x = new(3); return 0; }
+fn h() -> int { *char s = 5; return 1; }
+fn main() { return 0 }
diff --git a/docs/history/13-gap-fixes/code/tests/meta.zc b/docs/history/13-gap-fixes/code/tests/meta.zc
new file mode 100644
index 0000000..bc89454
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/meta.zc
@@ -0,0 +1,46 @@
+fn ipow(a, b) { let r = 1; while (b > 0) { r *= a; b--; } return r; }
+// a parse word that adds an operator to the compiler's tables
+immediate fn pow_op() { next(); add_binop("**", 11, "ipow c"); return 0; }
+pow_op
+
+// unless (cond) stmt: a parse word that emits code itself
+immediate fn unless()
+{
+	let a;
+	next();
+	expect(intern("(")); rval(); plainuse(expr()); rval(); expect(intern(")"));
+	emitseq(useq[0], ulen[0]);	// not
+	a = hole(); op(O_JZ);		// skip the body when the condition was true
+	substmt();
+	setlit(a, here);
+	return 0;
+}
+// repeat N { body }: a macro, built from token lists
+immediate fn repeat()
+{
+	let n, body, i = 0;
+	next(); n = tv; next();
+	body = grab();
+	while (i < n) { feed(qdup(body)); i++; }
+	free(d*body);
+	return 0;
+}
+fn main()
+{
+	putn(2 ** 10); putc(' '); putn(3 + 2 ** 3 * 2); putc(10);
+	unless (1 > 2) puts("unless ok\n");
+	unless (2 > 1) puts("wrong\n");
+	repeat 3 { putc('r'); }
+	putc(10);
+	let q = quote { putn(40 + 2); putc(10); return 7; };
+	putn(q[0]); putc(' ');
+	putn(eval(q)); putc(10);
+	let f = compile(q);
+	putn(f()); putc(10);
+	free(d*q);
+	let defs = quote { fn sq(x) { return x * x; } };
+	load(defs);
+	free(d*defs);
+	putn(evals("return sq(12);")); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/misc.zc b/docs/history/13-gap-fixes/code/tests/misc.zc
new file mode 100644
index 0000000..25fc53b
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/misc.zc
@@ -0,0 +1,30 @@
+// ct { ... } runs a block while compiling and leaves its result as a constant
+immediate fn ct()
+{
+	let q, v;
+	next();
+	q = grab();
+	v = eval(q);
+	free(d*q);
+	lit(v);
+	return 0;
+}
+// teach the asm syntax that p means out, like the old repl demo
+immediate fn teach() { next(); mnem[12] = 'p'; return 0; }
+teach
+
+fn countdown()
+{
+	asm { 5 :top 0 $ '0' + p 1 - 0 $ done z top j :done _ 10 p }
+	return 0;
+}
+fn main()
+{
+	putn(ct { let i = 0, s = 0; while (i < 10) { s += i; i++; } return s; }); putc(10);
+	countdown();
+	puts(lazy()); putc(10);
+	return 0;
+}
+// the analyzer is off from here on
+unchecked;
+fn lazy() { let p = new(3); p[0] = 'o'; p[1] = 'k'; return p; }
diff --git a/docs/history/13-gap-fixes/code/tests/overflow_data.zc b/docs/history/13-gap-fixes/code/tests/overflow_data.zc
new file mode 100644
index 0000000..3042f0a
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/overflow_data.zc
@@ -0,0 +1 @@
+fn main() { while (1) asm { 1 } return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/overflow_frame.zc b/docs/history/13-gap-fixes/code/tests/overflow_frame.zc
new file mode 100644
index 0000000..3897bf4
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/overflow_frame.zc
@@ -0,0 +1,2 @@
+fn big(n) { let a[500]; a[0] = n; return big(n + 1) + a[0]; }
+fn main() { return big(0); }
diff --git a/docs/history/13-gap-fixes/code/tests/overflow_return.zc b/docs/history/13-gap-fixes/code/tests/overflow_return.zc
new file mode 100644
index 0000000..9d5c622
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/overflow_return.zc
@@ -0,0 +1,2 @@
+fn deep(n) { return deep(n + 1) + 1; }
+fn main() { return deep(0); }
diff --git a/docs/history/13-gap-fixes/code/tests/runerr.sh b/docs/history/13-gap-fixes/code/tests/runerr.sh
new file mode 100755
index 0000000..23ea054
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/runerr.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+# runs every .zc in a folder (tests/errors by default) and checks the compiler
+# rejects it with the message on its first line: // expect: ...
+vm=${1:-zy}; dir=${2:-$(dirname "$0")/errors}; pass=0; fail=0
+for f in "$dir"/*.zc; do
+	want=$(head -1 "$f" | sed 's#^// expect: ##')
+	got=$($vm < "$f" 2>&1 | head -1)
+	if [[ "$got" == *"$want"* ]]; then pass=$((pass+1)); else fail=$((fail+1)); echo "FAIL $(basename $f): got [$got]"; fi
+done
+echo "rejected: $pass passed, $fail failed"
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/arg.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/arg.zc
new file mode 100644
index 0000000..b762c19
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/arg.zc
@@ -0,0 +1,5 @@
+// expect: type error: argument: expected *point, got *int
+typecheck on;
+struct point { int x, y; };
+fn f(*point p) -> int { return p.x; }
+fn main() { *int q = new(int); f(q); free(d*q); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/arith.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/arith.zc
new file mode 100644
index 0000000..76e3111
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/arith.zc
@@ -0,0 +1,3 @@
+// expect: type error: arithmetic needs numbers, got *int
+typecheck on;
+fn main() { *int p = 0; int x = p * 2; return x; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/assign.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/assign.zc
new file mode 100644
index 0000000..8b8a888
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/assign.zc
@@ -0,0 +1,3 @@
+// expect: type error: initializer: expected *char, got int
+typecheck on;
+fn main() { *char s = 5; return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/call.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/call.zc
new file mode 100644
index 0000000..7b03dbf
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/call.zc
@@ -0,0 +1,3 @@
+// expect: type error: only functions can be called, got int
+typecheck on;
+fn main() { int k = 3; return k(1); }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/deref.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/deref.zc
new file mode 100644
index 0000000..ed030f5
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/deref.zc
@@ -0,0 +1,3 @@
+// expect: type error: only pointers can be dereferenced, got int
+typecheck on;
+fn main() { int x = 3; return *x; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/field.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/field.zc
new file mode 100644
index 0000000..ba03697
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/field.zc
@@ -0,0 +1,3 @@
+// expect: point has no field z
+struct point { int x, y; };
+fn main() { point p; return p.z; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/generic.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/generic.zc
new file mode 100644
index 0000000..4a502ce
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/generic.zc
@@ -0,0 +1,4 @@
+// expect: type error: argument: expected int, got *char
+typecheck on;
+fn same<T>(T a, T b) -> T { return a; }
+fn main() { return same(1, "x"); }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/notstruct.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/notstruct.zc
new file mode 100644
index 0000000..0dff6bd
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/notstruct.zc
@@ -0,0 +1,2 @@
+// expect: .x: that's a int, not a struct or a pointer to one
+fn main() { int n = 1; return n.x; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/ret.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/ret.zc
new file mode 100644
index 0000000..cedd534
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/ret.zc
@@ -0,0 +1,4 @@
+// expect: type error: return value: expected bool, got *char
+typecheck on;
+fn f() -> bool { return "no"; }
+fn main() { return f(); }
diff --git a/docs/history/13-gap-fixes/code/tests/typeerrors/voidret.zc b/docs/history/13-gap-fixes/code/tests/typeerrors/voidret.zc
new file mode 100644
index 0000000..a897290
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeerrors/voidret.zc
@@ -0,0 +1,4 @@
+// expect: type error: return value: expected void, got int
+typecheck on;
+fn f() -> void { return 3; }
+fn main() { f(); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeoff.zc b/docs/history/13-gap-fixes/code/tests/typeoff.zc
new file mode 100644
index 0000000..e44e450
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeoff.zc
@@ -0,0 +1,2 @@
+// the typechecker is off unless asked for: this mismatch compiles and runs
+fn main() { *char s = 5; putn(s as int + 1); putc(10); return 0; }
diff --git a/docs/history/13-gap-fixes/code/tests/typeok.zc b/docs/history/13-gap-fixes/code/tests/typeok.zc
new file mode 100644
index 0000000..3cdee0c
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/typeok.zc
@@ -0,0 +1,22 @@
+// passes the typechecker: words mix with everything, literal 0 is null,
+// arrays decay to pointers, generic calls bind their parameters
+typecheck on;
+struct pair<A, B> { A a; B b; };
+fn mk<A, B>(A x, B y) -> *pair<A, B>.u { *pair<A, B> p = new(pair<A, B>); p.a = x; p.b = y; return u*p; }
+fn left<A, B>(*pair<A, B> p) -> A { return p.a; }
+fn strlen2(*char s) -> int { int n = 0; while (s[n]) n++; return n; }
+fn main() -> int
+{
+	*pair<int, *char> p = mk(3, "four");
+	int a = left(p);
+	*char s = p.b;
+	[8]char buf;
+	*char q = buf;
+	*int nothing = 0;
+	let w = 5;
+	int mixed = w + 1;
+	q[0] = 'h'; q[1] = 0;
+	putn(a + strlen2(s) + strlen2(buf) + mixed); putc(10);
+	free(d*p);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/types.zc b/docs/history/13-gap-fixes/code/tests/types.zc
new file mode 100644
index 0000000..ccbbd26
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/types.zc
@@ -0,0 +1,57 @@
+struct point { int x, y; };
+struct rect { point a, b; int tag; };
+struct list<T> { int len; *T items; };
+struct node { int v; *node next; };
+type num = int;
+
+int counter = 5;
+[4]int squares;
+point origin;
+
+fn area(*rect r) -> int { return (r.b.x - r.a.x) * (r.b.y - r.a.y); }
+fn mklist<T>(int cap) -> *list<T>.u
+{
+	*list<T> l = new(list<T>);
+	l.len = 0;
+	l.items = new(T, cap) as *T;
+	return u*l;
+}
+fn first<T>(*list<T> l) -> T { return l.items[0]; }
+fn sum(*node n) -> int { int s = 0; while (n) { s += n.v; n = n.next; } return s; }
+
+fn main()
+{
+	rect r;
+	r.a.x = 1; r.a.y = 2; r.b.x = 4; r.b.y = 6;
+	putn(area(&r)); putc(' ');
+	putn(sizeof(rect)); putc(' '); putn(sizeof(point)); putc(' '); putn(sizeof([3]rect)); putc(' ');
+	let p = new(point);	// let infers *point
+	p.x = 7; p->y = 8;
+	putn(p.x * p.y); putc(' ');
+	free(d*p);
+	*list<int> l = mklist<int>(4);
+	l.items[0] = 42; l.len = 1;
+	putn(first(l)); putc(' ');
+	free(d*l);
+	*node a = new(node), b = new(node);
+	a.v = 3; b.v = 4; a.next = b;
+	putn(sum(a)); putc(' ');
+	free(d*a);	// b went with it: a.next = b made a its owner
+	[3]point pts;
+	pts[2].y = 9;
+	putn(pts[2].y + counter); putc(' ');
+	num k = 3;
+	putn(k); putc(10);
+
+	// reflection
+	tprint(typeof(r)); putc(' '); tprint(typeof(&r)); putc(' '); tprint(typeof(l)); putc(' ');
+	tprint(sigof(mklist)); putc(' '); tprint(sigof(first)); putc(' '); tprint(sigofs("free")); putc(10);
+	let t = typeof(r), i = 0;
+	while (i < tnfields(t)) { puts(tfname(t, i)); putc(':'); tprint(tftype(t, i)); putc('@'); putn(tfoff(t, i)); putc(' '); i++; }
+	putc(10);
+	*point q = new(point);
+	tprint(typeof_obj(q)); putc(' '); putn(typeof_obj(q) == typeof(point)); putc(' '); putn(tkind(typeof_obj(q)) == TY_STRUCT);
+	free(d*q);
+	putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tests/umd.zc b/docs/history/13-gap-fixes/code/tests/umd.zc
new file mode 100644
index 0000000..ee463bf
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tests/umd.zc
@@ -0,0 +1,52 @@
+// lists as [len, items...], items owned by the list
+fn mklist(n) -> .u
+{
+	let l = new(n + 1);
+	l[0] = 0;
+	return u*l;
+}
+fn push(.m l, .d item) { l[l[0] + 1] = d*item; l[0] = l[0] + 1; return 0; }
+fn sum(.m l) { let s = 0, i = 1; while (i <= l[0]) { s += l[i][0]; i++; } return s; }
+fn box(v) -> .u { let b = new(1); b[0] = v; return u*b; }
+fn consume(.d b) { return b[0]; }
+
+fn main()
+{
+	let base = live_objects();
+	{
+		let l = mklist(8);		// u from mklist arrives m*here
+		let i = 0;
+		while (i < 5) {
+			let b = box(i * 10);	// m in the loop body
+			d*b;			// give it down
+			push(l, b);
+			i++;
+		}
+		putn(sum(l)); putc(' ');
+		putn(live_objects() - base); putc(' ');	// list + 5 boxes
+	}
+	putn(live_objects() - base); putc(' ');	// freed at the block's end, children too
+
+	// u handed up one block by assignment, and as a block value
+	let outer;
+	{
+		let t = box(7);
+		u*t;
+		outer = t;
+	}
+	let v = { let w = box(8); u*w };
+	putn(outer[0] + v[0]); putc(' ');
+
+	// d given away to a callee
+	let g = box(99);
+	putn(consume(d*g)); putc(' ');
+
+	// containers: child takes its parent's tag
+	let p = new(2), c = new(1);
+	c[0] = 5;
+	p[0] = c;
+	p[1] = new(3);
+	putn(p[0][0]); putc(' ');
+	putn(live_objects() - base); putc(10);
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/tools/build.zc b/docs/history/13-gap-fixes/code/tools/build.zc
new file mode 100644
index 0000000..a38e97f
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/tools/build.zc
@@ -0,0 +1,13 @@
+// compiles the rest of stdin (after the backtick) as a genome image at GORG
+// and writes it to stdout as little-endian 32-bit words.
+const OUT = 0x10000;
+fn main()
+{
+	let n = build_image(GORG, OUT), i = 0, w;
+	while (i < n) {
+		w = OUT[i];
+		putc(w); putc(w >> 8); putc(w >> 16); putc(w >> 24);
+		i++;
+	}
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/code/zc0.c b/docs/history/13-gap-fixes/code/zc0.c
new file mode 100644
index 0000000..4df587e
--- /dev/null
+++ b/docs/history/13-gap-fixes/code/zc0.c
@@ -0,0 +1,460 @@
+/* zc0: stage 0 of the bootstrap. a small c compiler for the subset of zc that
+   compiler.zc is written in. it reads zc source on stdin and writes a genome
+   header (vm words placed at GORG) on stdout, in the same image layout the
+   resident compiler's image mode produces. no lifetime analysis, no quote, no
+   parse words, no block expressions: those only exist in compiler.zc. tags
+   (m, d, -> u) and casts (as u, as d) are parsed and recorded in signatures
+   but not checked. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define GORG 0xC0000
+#define ZFP 0xA0000		/* frame pointer word */
+#define FTOP 0xF0000		/* frame stack grows down from here */
+#define MAXW 0x40000
+
+enum { T_EOF, T_NUM, T_ID, T_STR, T_OP };
+enum { K_FN = 1, K_GVAR, K_GARR, K_CONST, K_KW, K_ENH };
+enum { O_Q, O_LD, O_ST, O_PICK, O_DROP, O_SWAP, O_CALL, O_JMP, O_JZ, O_RET,
+	O_IN, O_EMPTY, O_OUT, O_ADD, O_SUB, O_MUL, O_AND, O_OR, O_XOR, O_SHR, O_LT };
+static const char *mn = "q@!$_~cjzr,?.+-*&|^><%";
+
+static char *src; static int pos, line = 1;
+static int tk, tv, glue; static char ts[4096];	/* current token */
+
+static int img[MAXW], here = GORG;
+static void emit(int w) { if (here - GORG >= MAXW) { fprintf(stderr, "image too big\n"); exit(1); } img[here++ - GORG] = w; }
+static void lit(int v) { emit((int)((unsigned)v * 2 + 1)); }
+static void op(int k) { emit(k * 2); }
+static void setlit(int at, int v) { img[at - GORG] = (int)((unsigned)v * 2 + 1); }
+
+static void die(const char *m) { fprintf(stderr, "zc0: line %d: %s (at '%s')\n", line, m, ts); exit(1); }
+
+/* ---- lexer ---- */
+static const char *ops3[] = { "<<=", ">>=", 0 };
+static const char *ops2[] = { "==", "!=", "<=", ">=", "<<", ">>", "&&", "||", "++", "--", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "->", 0 };
+static int esc(void)
+{
+	int c = src[pos++];
+	if (c != '\\') return c;
+	c = src[pos++];
+	switch (c) { case 'n': return 10; case 't': return 9; case 'r': return 13; case '0': return 0; case 'e': return 27; }
+	return c;
+}
+static void next(void)
+{
+	int ws = 0, i;
+	for (;;) {
+		while (src[pos] && isspace((unsigned char)src[pos])) { if (src[pos] == '\n') line++; pos++; ws = 1; }
+		if (src[pos] == '/' && src[pos + 1] == '/') { while (src[pos] && src[pos] != '\n') pos++; ws = 1; continue; }
+		if (src[pos] == '/' && src[pos + 1] == '*') { pos += 2; while (src[pos] && !(src[pos] == '*' && src[pos + 1] == '/')) { if (src[pos] == '\n') line++; pos++; } if (src[pos]) pos += 2; ws = 1; continue; }
+		break;
+	}
+	glue = !ws;
+	if (!src[pos] || src[pos] == '`') { tk = T_EOF; strcpy(ts, "<eof>"); return; }
+	if (isdigit((unsigned char)src[pos])) {
+		char *e; tv = (int)strtoul(src + pos, &e, 0); memcpy(ts, src + pos, e - src - pos); ts[e - src - pos] = 0; pos = e - src; tk = T_NUM; return;
+	}
+	if (isalpha((unsigned char)src[pos]) || src[pos] == '_') {
+		i = 0; while (isalnum((unsigned char)src[pos]) || src[pos] == '_') ts[i++] = src[pos++];
+		ts[i] = 0; tk = T_ID; return;
+	}
+	if (src[pos] == '\'') { pos++; tv = esc(); if (src[pos++] != '\'') die("bad char literal"); tk = T_NUM; strcpy(ts, "'c'"); return; }
+	if (src[pos] == '"') { pos++; i = 0; while (src[pos] && src[pos] != '"') ts[i++] = (char)esc(); ts[i] = 0; pos++; tk = T_STR; return; }
+	tk = T_OP;
+	for (i = 0; ops3[i]; i++) if (!strncmp(src + pos, ops3[i], 3)) { strcpy(ts, ops3[i]); pos += 3; return; }
+	for (i = 0; ops2[i]; i++) if (!strncmp(src + pos, ops2[i], 2)) { strcpy(ts, ops2[i]); pos += 2; return; }
+	ts[0] = src[pos++]; ts[1] = 0;
+}
+static int is(const char *s) { return (tk == T_OP || tk == T_ID) && !strcmp(ts, s); }
+static int accept(const char *s) { if (is(s)) { next(); return 1; } return 0; }
+static void expect(const char *s) { if (!accept(s)) { char b[64]; sprintf(b, "expected '%s'", s); die(b); } }
+static char *ident(void) { static char b[8][256]; static int k; char *r = b[k++ & 7]; if (tk != T_ID) die("expected a name"); strcpy(r, ts); next(); return r; }
+
+/* ---- symbols ---- */
+typedef struct { char name[64]; int kind, val, sig, defd; } Sym;
+static Sym sy[4096]; static int nsy;
+typedef struct { int at, sym; } Fix;
+static Fix fx[65536]; static int nfx;
+static Sym *find(const char *n) { int i; for (i = nsy; i--;) if (!strcmp(sy[i].name, n)) return &sy[i]; return 0; }
+static Sym *add(const char *n, int kind, int val)
+{
+	Sym *s = find(n);
+	if (s && s->kind == K_FN && kind == K_FN && !s->defd) { s->val = val; return s; }	/* prototype or forward use */
+	s = &sy[nsy++]; strncpy(s->name, n, 63); s->kind = kind; s->val = val; s->defd = 1; s->sig = 0; return s;
+}
+static void fnref(const char *n)	/* push a function address, fixing it up later if needed */
+{
+	Sym *s = find(n);
+	if (!s) { s = add(n, K_FN, 0); s->defd = 0; }
+	if (s->kind != K_FN) die("not a function");
+	if (s->defd) { lit(s->val); return; }
+	fx[nfx].at = here; fx[nfx++].sym = (int)(s - sy); lit(0);
+}
+
+/* ---- locals ---- */
+typedef struct { char name[64]; int slot, arr; } Loc;
+static Loc lo[1024]; static int nlo, nslot, infn;
+static Loc *findl(const char *n) { int i; for (i = nlo; i--;) if (!strcmp(lo[i].name, n)) return &lo[i]; return 0; }
+static void laddr(int k) { lit(ZFP); op(O_LD); if (k) { lit(k); op(O_ADD); } }
+
+/* ---- operator tables ---- */
+static void seq_isz(void) { lit(0); op(O_PICK); lit(0); op(O_SWAP); op(O_SUB); op(O_OR); lit(31); op(O_SHR); lit(1); op(O_ADD); }
+static void seq_nz(void) { lit(0); op(O_PICK); lit(0); op(O_SWAP); op(O_SUB); op(O_OR); lit(31); op(O_SHR); lit(0); op(O_SWAP); op(O_SUB); }
+static int binprec(void)
+{
+	static const char *n[] = { "*", "/", "%", "+", "-", "<<", ">>", "<", ">", "<=", ">=", "==", "!=", "&", "^", "|", "&&", "||", 0 };
+	static int p[] = { 10, 10, 10, 9, 9, 8, 8, 7, 7, 7, 7, 6, 6, 5, 4, 3, 2, 1 };
+	int i;
+	if (tk != T_OP) return 0;
+	for (i = 0; n[i]; i++) if (!strcmp(ts, n[i])) return p[i];
+	return 0;
+}
+static void binop(const char *o)
+{
+	if (!strcmp(o, "*")) op(O_MUL);
+	else if (!strcmp(o, "/")) { fnref("zdiv"); op(O_CALL); }
+	else if (!strcmp(o, "%")) { fnref("zmod"); op(O_CALL); }
+	else if (!strcmp(o, "+")) op(O_ADD);
+	else if (!strcmp(o, "-")) op(O_SUB);
+	else if (!strcmp(o, "<<")) { fnref("zshl"); op(O_CALL); }
+	else if (!strcmp(o, ">>")) op(O_SHR);
+	else if (!strcmp(o, "<")) op(O_LT);
+	else if (!strcmp(o, ">")) { op(O_SWAP); op(O_LT); }
+	else if (!strcmp(o, "<=")) { op(O_SWAP); op(O_LT); lit(1); op(O_XOR); }
+	else if (!strcmp(o, ">=")) { op(O_LT); lit(1); op(O_XOR); }
+	else if (!strcmp(o, "==")) { op(O_SUB); seq_isz(); }
+	else if (!strcmp(o, "!=")) { op(O_SUB); seq_nz(); }
+	else if (!strcmp(o, "&")) op(O_AND);
+	else if (!strcmp(o, "^")) op(O_XOR);
+	else if (!strcmp(o, "|")) op(O_OR);
+	else die("bad operator");
+}
+
+/* ---- constant expressions (globals, array sizes, const) ---- */
+static int cexpr(void);
+static int cprim(void)
+{
+	int v; Sym *s;
+	if (tk == T_NUM) { v = tv; next(); return v; }
+	if (accept("-")) return -cprim();
+	if (accept("~")) return ~cprim();
+	if (accept("(")) { v = cexpr(); expect(")"); return v; }
+	if (tk == T_ID && (s = find(ts)) && (s->kind == K_CONST || (s->kind != K_GVAR && s->defd))) { next(); return s->val; }
+	die("constant expected"); return 0;
+}
+static int cexpr(void)
+{
+	int v = cprim();
+	for (;;) {
+		if (accept("+")) v += cprim(); else if (accept("-")) v -= cprim();
+		else if (accept("*")) v *= cprim(); else if (accept("|")) v |= cprim();
+		else if (accept("&")) v &= cprim(); else if (accept("<<")) v <<= cprim();
+		else if (accept(">>")) v >>= cprim(); else return v;
+	}
+}
+
+/* ---- expressions ---- */
+static int lv;	/* the stack top is an address not yet loaded */
+static void rval(void) { if (lv) { op(O_LD); lv = 0; } }
+static void expr(void);
+static void strlit(void)	/* inline string: jump over it, push its address */
+{
+	int j = here, a, i, n = (int)strlen(ts);
+	lit(0); op(O_JMP); a = here;
+	for (i = 0; i < n; i++) emit((unsigned char)ts[i]);
+	emit(0); setlit(j, here); lit(a); next();
+}
+static int args(void) { int n = 0; expect("("); if (!accept(")")) { do { expr(); rval(); n++; } while (accept(",")); expect(")"); } return n; }
+static void asmblock(void);
+static void primary(void)
+{
+	char *n; Loc *l; Sym *s;
+	lv = 0;
+	if (tk == T_NUM) { lit(tv); next(); return; }
+	if (tk == T_STR) { strlit(); return; }
+	if (accept("(")) { expr(); expect(")"); return; }
+	if (is("asm")) { next(); asmblock(); return; }
+	n = ident();
+	if ((l = findl(n))) { laddr(l->slot); lv = !l->arr; return; }
+	s = find(n);
+	if (s && s->kind == K_CONST) { lit(s->val); return; }
+	if (s && s->kind == K_GVAR) { lit(s->val); lv = 1; return; }
+	if (s && s->kind == K_GARR) { lit(s->val); return; }
+	if (is("(")) { args(); fnref(n); op(O_CALL); return; }
+	fnref(n);
+}
+static void incdec(int post, int d)
+{
+	if (!lv) die("++/-- needs an lvalue");
+	lv = 0;
+	if (post) { lit(0); op(O_PICK); op(O_LD); lit(0); op(O_PICK); lit(d); op(O_ADD); lit(2); op(O_PICK); op(O_ST); op(O_SWAP); op(O_DROP); }
+	else { lit(0); op(O_PICK); op(O_LD); lit(d); op(O_ADD); lit(0); op(O_PICK); lit(2); op(O_PICK); op(O_ST); op(O_SWAP); op(O_DROP); }
+}
+static void postfix(void)
+{
+	int n;
+	primary();
+	for (;;) {
+		if (accept("[")) { rval(); expr(); rval(); expect("]"); op(O_ADD); lv = 1; }
+		else if (is("(")) { rval(); n = args(); lit(n); op(O_PICK); op(O_CALL); op(O_SWAP); op(O_DROP); }
+		else if (accept("++")) incdec(1, 1);
+		else if (accept("--")) incdec(1, -1);
+		else if (accept("as")) ident();
+		else return;
+	}
+}
+static void unary(void)
+{
+	if (accept("-")) { unary(); rval(); lit(0); op(O_SWAP); op(O_SUB); }
+	else if (accept("!")) { unary(); rval(); seq_isz(); }
+	else if (accept("~")) { unary(); rval(); lit(-1); op(O_XOR); }
+	else if (accept("*")) { unary(); rval(); lv = 1; }
+	else if (accept("&")) { unary(); if (!lv) die("& needs an lvalue"); lv = 0; }
+	else if (accept("++")) { unary(); incdec(0, 1); }
+	else if (accept("--")) { unary(); incdec(0, -1); }
+	else if (tk == T_ID && (!strcmp(ts, "u") || !strcmp(ts, "m") || !strcmp(ts, "d"))) { next(); expect("*"); unary(); }	/* u*x: a recast, no code */
+	else postfix();
+}
+static void bin(int minp)
+{
+	int p, a, b; char o[8];
+	unary();
+	while ((p = binprec()) && p >= minp) {
+		strcpy(o, ts); next(); rval();
+		if (!strcmp(o, "&&")) {
+			a = here; lit(0); op(O_JZ); bin(p + 1); rval(); seq_nz();
+			b = here; lit(0); op(O_JMP); setlit(a, here); lit(0); setlit(b, here);
+		} else if (!strcmp(o, "||")) {
+			a = here; lit(0); op(O_JZ); lit(1); b = here; lit(0); op(O_JMP);
+			setlit(a, here); bin(p + 1); rval(); seq_nz(); setlit(b, here);
+		} else { bin(p + 1); rval(); binop(o); }
+		lv = 0;
+	}
+}
+static void expr(void)
+{
+	char o[8];
+	bin(1);
+	if (is("=")) {
+		if (!lv) die("assignment needs an lvalue");
+		next(); expr(); rval();
+		op(O_SWAP); lit(1); op(O_PICK); op(O_SWAP); op(O_ST); lv = 0;
+	} else if (tk == T_OP && strlen(ts) >= 2 && ts[strlen(ts) - 1] == '=' && strcmp(ts, "==") && strcmp(ts, "!=") && strcmp(ts, "<=") && strcmp(ts, ">=")) {
+		if (!lv) die("assignment needs an lvalue");
+		strcpy(o, ts); o[strlen(o) - 1] = 0; next();
+		lit(0); op(O_PICK); op(O_LD); lv = 0; expr(); rval(); binop(o);
+		op(O_SWAP); lit(1); op(O_PICK); op(O_SWAP); op(O_ST); lv = 0;
+	}
+}
+
+/* ---- asm blocks: raw vm words ---- */
+static void asmblock(void)
+{
+	char ln[128][64], rn[256][64]; int la[128], nl = 0, ra[256], nr = 0, i, k; const char *c;
+	Loc *l; Sym *s;
+	expect("{");
+	while (!accept("}")) {
+		if (tk == T_EOF) die("unterminated asm");
+		if (tk == T_NUM) { lit(tv); next(); continue; }
+		if (tk == T_STR) { strlit(); continue; }
+		if (accept("#")) { if (tk != T_NUM) die("# needs a number"); emit(tv); next(); continue; }
+		if (is("-")) { next(); if (tk == T_NUM && glue) { lit(-tv); next(); } else op(O_SUB); continue; }
+		if (accept(":")) { strcpy(ln[nl], ident()); la[nl++] = here; continue; }
+		if (strlen(ts) == 1 && (c = strchr(mn, ts[0]))) { op((int)(c - mn)); next(); continue; }
+		if (tk != T_ID) die("bad asm token");
+		if ((l = findl(ts))) { laddr(l->slot); next(); continue; }
+		if ((s = find(ts)) && s->kind != K_FN) { lit(s->val); next(); continue; }
+		if (s) { fnref(ts); next(); continue; }
+		strcpy(rn[nr], ts); ra[nr++] = here; lit(0); next();	/* a label of this block */
+	}
+	for (i = 0; i < nr; i++) {
+		for (k = -1; ++k < nl && strcmp(ln[k], rn[i]);) ;
+		if (k == nl) die("unknown asm label");
+		setlit(ra[i], la[k]);
+	}
+}
+
+/* ---- statements ---- */
+static int brk[256][64], nbrk[256], cont[256], nloop;
+static int epi[1024], nepi;
+static void stmt(void);
+static void block(void)
+{
+	int save = nlo;
+	expect("{");
+	while (!accept("}")) { if (tk == T_EOF) die("missing }"); stmt(); }
+	nlo = save;
+}
+static void jmp_to(int t) { lit(t); op(O_JMP); }
+static void loopbody(int contaddr)
+{
+	nbrk[nloop] = 0; cont[nloop++] = contaddr;
+	stmt();
+	nloop--;
+}
+static void patchbreaks(void) { int i; for (i = 0; i < nbrk[nloop]; i++) setlit(brk[nloop][i], here); }
+static void stmt(void)
+{
+	int a, b, c, d;
+	if (accept(";")) return;
+	if (is("{")) { block(); return; }
+	if (accept("let") || accept("var")) {
+		do {
+			Loc *l = &lo[nlo++]; strcpy(l->name, ident()); l->arr = 0;
+			if (accept("[")) { int n = cexpr(); expect("]"); nslot += n; l->slot = nslot - n; l->arr = 1; }
+			else l->slot = nslot++;
+			if (accept("=")) { expr(); rval(); laddr(l->slot); op(O_ST); }
+		} while (accept(","));
+		expect(";"); return;
+	}
+	if (accept("unchecked")) { stmt(); return; }
+	if (accept("if")) {
+		expect("("); expr(); rval(); expect(")");
+		a = here; lit(0); op(O_JZ); stmt();
+		if (accept("else")) { b = here; lit(0); op(O_JMP); setlit(a, here); stmt(); setlit(b, here); }
+		else setlit(a, here);
+		return;
+	}
+	if (accept("while")) {
+		c = here; expect("("); expr(); rval(); expect(")");
+		a = here; lit(0); op(O_JZ);
+		loopbody(c); jmp_to(c); setlit(a, here); patchbreaks(); return;
+	}
+	if (accept("for")) {
+		int save = nlo;
+		expect("(");
+		if (!is(";")) { if (is("let") || is("var")) { stmt(); goto cond; } expr(); rval(); op(O_DROP); }
+		expect(";");
+	cond:	c = here;
+		if (!is(";")) { expr(); rval(); } else lit(1);
+		expect(";");
+		a = here; lit(0); op(O_JZ); b = here; lit(0); op(O_JMP);
+		d = here;
+		if (!is(")")) { expr(); rval(); op(O_DROP); }
+		expect(")"); jmp_to(c);
+		setlit(b, here);
+		loopbody(d); jmp_to(d); setlit(a, here); patchbreaks();
+		nlo = save; return;
+	}
+	if (accept("break")) { if (!nloop) die("break outside a loop"); brk[nloop - 1][nbrk[nloop - 1]++] = here; lit(0); op(O_JMP); expect(";"); return; }
+	if (accept("continue")) { if (!nloop) die("continue outside a loop"); jmp_to(cont[nloop - 1]); expect(";"); return; }
+	if (accept("return")) {
+		if (!is(";")) { expr(); rval(); } else lit(0);
+		expect(";"); epi[nepi++] = here; lit(0); op(O_JMP); return;
+	}
+	if (is("asm")) { next(); asmblock(); return; }
+	expr(); rval(); op(O_DROP); expect(";");
+}
+
+/* ---- top level ---- */
+static void fndef(void)
+{
+	char *n = ident(); Sym *s; int np = 0, tags = 0, t, ret = 0, frame, i;
+	char pn[16][64];
+	s = find(n);
+	if (!s || s->kind != K_FN) { s = add(n, K_FN, 0); s->defd = 0; }
+	expect("(");
+	if (!accept(")")) {
+		do {
+			t = 0;
+			if (accept(".")) {	/* .m name, .d name */
+				if (is("m")) t = 1; else if (is("d")) t = 2; else die("a parameter tag is .m or .d");
+				next();
+			}
+			if (np < 12) tags += t << (2 * np);
+			strcpy(pn[np++], ident());
+		} while (accept(","));
+		expect(")");
+	}
+	if (accept("->")) { expect("."); if (strcmp(ident(), "u")) die("the return tag is -> .u"); ret = 1; }
+	s->sig = ret + 2 * np + 64 * tags;
+	if (accept(";")) return;	/* prototype */
+	if (s->defd) die("function defined twice");
+	s->val = here; s->defd = 1;
+	nlo = 0; nslot = 0; nepi = 0; infn = 1;
+	for (i = 0; i < np; i++) { strcpy(lo[nlo].name, pn[i]); lo[nlo].arr = 0; lo[nlo++].slot = nslot++; }
+	/* prologue: fp -= frame, then pop the arguments into their slots */
+	lit(ZFP); op(O_LD); frame = here; lit(0); op(O_SUB); lit(ZFP); op(O_ST);
+	for (i = np; i--;) { laddr(i); op(O_ST); }
+	block();
+	lit(0);
+	for (i = 0; i < nepi; i++) setlit(epi[i], here);
+	lit(ZFP); op(O_LD); lit(nslot); op(O_ADD); lit(ZFP); op(O_ST); op(O_RET);
+	setlit(frame, nslot);
+	infn = 0;
+}
+/* enhance name(params) [-> n] micro "recipe"; or ... vm { asm };
+   emits the install descriptor; the booted genome installs it */
+static int nenh;
+static void enhdef(void)
+{
+	char *n = ident(), pn[8][64]; int np = 0, nout = 1, d, na, pay, len = 0, i, j; Sym *s;
+	expect("(");
+	if (!accept(")")) { do { if (np == 8) die("at most 8 inputs"); strcpy(pn[np++], ident()); } while (accept(",")); expect(")"); }
+	if (accept("->")) { nout = tv; next(); }
+	d = here; for (i = 0; i < 7; i++) emit(0);
+	na = here; for (i = 0; i < np; i++) emit(0);
+	for (i = 0; i < np; i++) { img[na + i - GORG] = here; for (j = 0; pn[i][j]; j++) emit((unsigned char)pn[i][j]); emit(0); }
+	if (accept("micro")) { pay = here; while (tk == T_STR) { for (j = 0; ts[j]; j++) emit((unsigned char)ts[j]); next(); } emit(0); }
+	else if (accept("vm")) { pay = here; asmblock(); op(O_RET); len = here - pay; img[d + 1 - GORG] = 1; }
+	else die("expected micro or vm");
+	img[d - GORG] = nenh; img[d + 2 - GORG] = np; img[d + 3 - GORG] = nout;
+	img[d + 4 - GORG] = pay; img[d + 5 - GORG] = len; img[d + 6 - GORG] = na;
+	s = add(n, K_ENH, nenh++); s->sig = np + nout * 16 + d * 256;
+	expect(";");
+}
+static void top(void)
+{
+	while (tk != T_EOF) {
+		if (accept("unchecked")) continue;
+		if (accept("fn")) { fndef(); continue; }
+		if (accept("const")) { do { char *n = ident(); expect("="); add(n, K_CONST, cexpr()); } while (accept(",")); expect(";"); continue; }
+		if (accept("enhance")) { enhdef(); continue; }
+		if (accept("let") || accept("var")) {
+			do {
+				char *n = ident();
+				if (accept("[")) { int k = cexpr(), a = here; expect("]"); while (k--) emit(0); add(n, K_GARR, a); }
+				else {
+					int a = here; add(n, K_GVAR, a); emit(0);
+					if (accept("=")) {
+						if (tk == T_STR) { int i, l = (int)strlen(ts); img[a - GORG] = here; for (i = 0; i < l; i++) emit((unsigned char)ts[i]); emit(0); next(); }
+						else img[a - GORG] = cexpr();
+					}
+				}
+			} while (accept(","));
+			expect(";"); continue;
+		}
+		die("expected fn, var or const");
+	}
+}
+
+int main(void)
+{
+	static char buf[1 << 22]; int n = (int)fread(buf, 1, sizeof buf - 1, stdin), i, j; Sym *st;
+	buf[n] = 0; src = buf; next();
+	/* image header: set the frame pointer, jump to start, then the symbol blob pointer and image end */
+	lit(FTOP); lit(ZFP); op(O_ST); fnref("start"); op(O_JMP); emit(0); emit(0);
+	top();
+	for (i = 0; i < nfx; i++) {
+		Sym *s = &sy[fx[i].sym];
+		if (!s->defd) { fprintf(stderr, "zc0: undefined function %s\n", s->name); return 1; }
+		setlit(fx[i].at, s->val);
+	}
+	if (!(st = find("start")) || !st->defd) { fprintf(stderr, "zc0: no start\n"); return 1; }
+	/* symbol blob: kind, value, sig, name chars, 0 ... then a 0 kind */
+	img[5] = here;
+	for (i = 0; i < nsy; i++) {
+		emit(sy[i].kind); emit(sy[i].val); emit(sy[i].sig);
+		for (j = 0; sy[i].name[j]; j++) emit((unsigned char)sy[i].name[j]);
+		emit(0);
+	}
+	emit(0);
+	img[6] = here;
+	printf("#define GORG %d\n#define GLEN %d\nstatic const int genome[] = {", GORG, here - GORG);
+	for (i = 0; i < here - GORG; i++) printf("%s%d", !i ? "\n" : i % 16 ? "," : ",\n", img[i]);
+	printf("\n};\n");
+	return 0;
+}
diff --git a/docs/history/13-gap-fixes/notes.md b/docs/history/13-gap-fixes/notes.md
new file mode 100644
index 0000000..f7e5ab5
--- /dev/null
+++ b/docs/history/13-gap-fixes/notes.md
@@ -0,0 +1,48 @@
+# gap fixes
+
+code/ next to this file is the tree at the end of this stage.
+
+## message 13
+
+> gaps
+> 1. when there's a var state change to d, mark that var as dead by default for any other scope that can access it afterwards. u is fine since it just returns
+> 2. any suggestions for a cheap fix?
+> 3. it's fine, rare occurrence (probably?), suggest a fix
+> 4. fix that
+> 5. suggest a fix
+> 6. fix
+> 7. fix
+
+**summary:** the numbers followed the gap list from my previous chat message. here's what each one got.
+
+**1. joins.** a variable that became d, or was given away, on any path is dead after the join, and fixup code frees it on the paths that still own it. a loop's exit state is the join of its breaks and its normal exit. giving something away on a path that loops back is still an error. u and borrows don't get the dead treatment.
+
+**2, 3 and 5.** suggestions only, now under open ends: a quarantine on reuse plus "borrowed from" marks on pointer-typed values for aliases, a stack-depth opcode for the collector, and page-indexed invalidation plus per-slot install tracking for the jit.
+
+**4. heap.** a buddy allocator.
+
+**6. stack checks.** all three stacks are checked: data and return at every block exit on all backends, and frames in every prologue.
+
+**7. the small stuff.** error recovery with up to 20 reported errors, line numbers carried in token lists, a signature prescan over the whole unit so prototypes are optional, storing into a borrowed object moving the object automatically, `?:`, and go-style `switch`. on the side, a 4-token lookahead fixed `**` declarations.
+
+## message 14
+
+> how costly is it if we add a counter to each block to see how many times it runs, then run the optimizer on it if it's a hot path?
+
+> continue
+
+**summary:** answered without building anything. about 4 instructions per block entry while a block is being counted, and nothing once its optimized translation replaces it. the optimizing pass would reuse the enhancement lifter, optimizer and register allocator. lifting whole blocks would need jz side exits and barriers at calls and i/o. compiling a block that way takes microseconds, against milliseconds for llvm, and keeping values in registers instead of the memory stack likely gives 2 to 4x on tight loops. it's listed under open ends. then the gap fixes continued.
+
+## working notes
+
+the join rule from message 1 needed a place to put frees, because the merged state is only known after the last path has compiled. for if/else, the then branch already jumps over the else, so that jump now lands on a small fixup block after the else when it has frees to do, and on the join otherwise. if without else does its then-fixups inline, since the skip path's state (the state before the branch) is known in advance. loops record the states at every break in an exit record, and after the loop each break gets its own fixup stub, or a direct jump when it has nothing to free. the normal exit's fixups come last and fall into the end. switch is built on the same loop frames, with continue skipping past them to the real loop.
+
+error recovery without exceptions: the vm can't unwind its own stacks, so a syntax error returns normally and sets panic. the error consumes the token it happened on, which guarantees every loop makes progress, and statement and top-level parsing skip ahead until panic clears. the risky part was code after an error that used a bad lookup result (sval[-1] and the like), which on the jit would read outside memory. those spots return safe defaults now.
+
+the prescan reads the whole unit first, packed 4 chars to a word (a char per word would have needed 400k words of heap for the compiler's own source), then lexes it once with the analyzer and errors muted. signatures it finds are marked as prescanned, so a real definition quietly overrides a wrong guess.
+
+bugs on the way: deleting a one-line function with a "find the next closing brace" helper also deleted the function after it. the variable d bit again in new code, since u, m and d are reserved. and a rename helper turned die into sdie when it was supposed to produce serr.
+
+the buddy heap: freed blocks merge with their buddy while it's free, the same size, and inside the same top-level chunk. the sweep walks the heap by block sizes, and a merge can swallow the block that comes next, so the sweep continues from the end of the merged block. a merge also clears the absorbed header, so no stale header can look like a free block later.
+
+numbers: the genome is 71014 words. the per-prologue frame check costs about 12 words per function, which accounts for most of the growth.