[INFO] cloning repository https://github.com/Achtuur/scope-graph
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Achtuur/scope-graph" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAchtuur%2Fscope-graph", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAchtuur%2Fscope-graph'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 52e96e73a01bf3f05e045b7aaa2103463aedd67e
[INFO] testing Achtuur/scope-graph against 1.83.0 for beta-1.84.0-4-retry
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FAchtuur%2Fscope-graph" "/workspace/builds/worker-3-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc1/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/Achtuur/scope-graph on toolchain 1.83.0
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.83.0" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/Achtuur/scope-graph
[INFO] finished tweaking git repo https://github.com/Achtuur/scope-graph
[INFO] tweaked toml for git repo https://github.com/Achtuur/scope-graph written to /workspace/builds/worker-3-tc1/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.83.0" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 64 packages to latest compatible versions
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.83.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded thiserror v1.0.69
[INFO] [stderr]   Downloaded thiserror-impl v1.0.69
[INFO] [stderr]   Downloaded futures v0.3.31
[INFO] [stderr]   Downloaded winnow v0.6.20
[INFO] [stderr]   Downloaded anstyle-query v1.1.2
[INFO] [stderr]   Downloaded anstyle-parse v0.2.6
[INFO] [stderr]   Downloaded anstream v0.3.2
[INFO] [stderr]   Downloaded anstyle v1.0.10
[INFO] [stderr]   Downloaded terminal_size v0.4.1
[INFO] [stderr]   Downloaded scopegraphs-regular-expressions v0.3.3
[INFO] [stderr]   Downloaded scopegraphs v0.3.3
[INFO] [stderr]   Downloaded anstyle-wincon v1.0.2
[INFO] [stderr]   Downloaded colorchoice v1.0.3
[INFO] [stderr]   Downloaded is-terminal v0.4.13
[INFO] [stderr]   Downloaded scopegraphs-macros v0.3.3
[INFO] [stderr]   Downloaded scopegraphs-prust-lib v0.1.0
[INFO] [stderr]   Downloaded windows-sys v0.59.0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:f3a9d4ad9d972b27faf3965f35b62e55ba32bbce8f20bc8fe909558a86702fde" "/opt/rustwide/cargo-home/bin/cargo" "+1.83.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 1931638962b7edf6e9b4ec1524b46200afabe738a6cda00495a73045d504bc80
[INFO] running `Command { std: "docker" "start" "-a" "1931638962b7edf6e9b4ec1524b46200afabe738a6cda00495a73045d504bc80", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1931638962b7edf6e9b4ec1524b46200afabe738a6cda00495a73045d504bc80", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1931638962b7edf6e9b4ec1524b46200afabe738a6cda00495a73045d504bc80", kill_on_drop: false }`
[INFO] [stdout] 1931638962b7edf6e9b4ec1524b46200afabe738a6cda00495a73045d504bc80
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:f3a9d4ad9d972b27faf3965f35b62e55ba32bbce8f20bc8fe909558a86702fde" "/opt/rustwide/cargo-home/bin/cargo" "+1.83.0" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] d4c007d264728881d64399eb2e202a82e592068fb0ed34af2860bf9343e7274f
[INFO] running `Command { std: "docker" "start" "-a" "d4c007d264728881d64399eb2e202a82e592068fb0ed34af2860bf9343e7274f", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.92
[INFO] [stderr]    Compiling unicode-ident v1.0.14
[INFO] [stderr]    Compiling thiserror v1.0.69
[INFO] [stderr]    Compiling autocfg v1.4.0
[INFO] [stderr]    Compiling futures-sink v0.3.31
[INFO] [stderr]    Compiling futures-core v0.3.31
[INFO] [stderr]    Compiling pin-project-lite v0.2.15
[INFO] [stderr]    Compiling futures-io v0.3.31
[INFO] [stderr]    Compiling futures-task v0.3.31
[INFO] [stderr]    Compiling winnow v0.6.20
[INFO] [stderr]    Compiling log v0.4.22
[INFO] [stderr]    Compiling bumpalo v3.16.0
[INFO] [stderr]    Compiling scopegraphs-prust-lib v0.1.0
[INFO] [stderr]    Compiling regex-automata v0.4.9
[INFO] [stderr]    Compiling futures-channel v0.3.31
[INFO] [stderr]    Compiling slab v0.4.9
[INFO] [stderr]    Compiling futures-util v0.3.31
[INFO] [stderr]    Compiling quote v1.0.37
[INFO] [stderr]    Compiling syn v2.0.90
[INFO] [stderr]    Compiling sclang v0.1.0 (/opt/rustwide/workdir/sclang)
[INFO] [stdout] warning: unused import: `PathBuf`
[INFO] [stdout]  --> sclang/src/expr.rs:1:34
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{io::Read, path::{Path, PathBuf}, str::FromStr};
[INFO] [stdout]   |                                  ^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `any`, `separated_pair`, `separated`, `take_until`, and `terminated`
[INFO] [stdout]  --> sclang/src/expr.rs:3:91
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t, separated, separated_pair, terminated}, error::{ParserError, StrContext, StrContextValue}, stream::{AsChar, Stream}, token::{any, take_until, t...
[INFO] [stdout]   |       ^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^                                                                                        ^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `StrContextValue`, `StrContext`, `any`, `cut_err`, `eof`, `fail`, `not`, `preceded`, `stream::AsChar`, `take_until`, `take_while`, and `terminated`
[INFO] [stdout]  --> sclang/src/types.rs:3:27
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...::{cut_err, delimited, eof, fail, not, opt, preceded, terminated}, error::{StrContext, StrContextValue}, stream::AsChar, token::{any, take_until, take_while...
[INFO] [stdout]   |       ^^^^^^^             ^^^  ^^^^  ^^^       ^^^^^^^^  ^^^^^^^^^^           ^^^^^^^^^^  ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^          ^^^  ^^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling regex v1.11.1
[INFO] [stderr]    Compiling scope-graph v0.1.0 (/opt/rustwide/workdir/scope-graph)
[INFO] [stdout] warning: unused import: `regex::Regex`
[INFO] [stdout]  --> scope-graph/src/scopegraph.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use regex::Regex;
[INFO] [stdout]   |     ^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `LabelRegex`
[INFO] [stdout]  --> scope-graph/src/scopegraph.rs:5:71
[INFO] [stdout]   |
[INFO] [stdout] 5 | use crate::{data::ScopeGraphData, label::ScopeGraphLabel, lbl_regex::{LabelRegex, LabelRegexMatcher}, path::Path, scope::Scope};
[INFO] [stdout]   |                                                                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `array::IntoIter` and `rc::Rc`
[INFO] [stdout]  --> scope-graph/src/path.rs:1:11
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{array::IntoIter, rc::Rc};
[INFO] [stdout]   |           ^^^^^^^^^^^^^^^  ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `id` is never used
[INFO] [stdout]   --> scope-graph/src/scope.rs:16:12
[INFO] [stdout]    |
[INFO] [stdout] 10 | impl Scope {
[INFO] [stdout]    | ---------- method in this implementation
[INFO] [stdout] ...
[INFO] [stdout] 16 |     pub fn id(&self) -> usize {
[INFO] [stdout]    |            ^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variants `OneOrMore` and `Or` are never constructed
[INFO] [stdout]   --> scope-graph/src/lbl_regex.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 7  | pub enum LabelRegex<Lbl: ScopeGraphLabel> {
[INFO] [stdout]    |          ---------- variants in this enum
[INFO] [stdout] ...
[INFO] [stdout] 13 |     OneOrMore(Lbl),
[INFO] [stdout]    |     ^^^^^^^^^
[INFO] [stdout] 14 |     Or(Rc<Self>, Rc<Self>),
[INFO] [stdout]    |     ^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `LabelRegex` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: associated function `or` is never used
[INFO] [stdout]   --> scope-graph/src/lbl_regex.rs:18:12
[INFO] [stdout]    |
[INFO] [stdout] 17 | impl<Lbl: ScopeGraphLabel + Clone> LabelRegex<Lbl> {
[INFO] [stdout]    | -------------------------------------------------- associated function in this implementation
[INFO] [stdout] 18 |     pub fn or(reg1: Self, reg2: Self) -> Self {
[INFO] [stdout]    |            ^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: static variable `ScopeCounter` should have an upper case name
[INFO] [stdout]  --> scope-graph/src/scope.rs:4:8
[INFO] [stdout]   |
[INFO] [stdout] 4 | static ScopeCounter: AtomicUsize = AtomicUsize::new(0);
[INFO] [stdout]   |        ^^^^^^^^^^^^ help: convert the identifier to upper case: `SCOPE_COUNTER`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_upper_case_globals)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling futures v0.3.31
[INFO] [stderr]    Compiling thiserror-impl v1.0.69
[INFO] [stderr]    Compiling scopegraphs-regular-expressions v0.3.3
[INFO] [stderr]    Compiling scopegraphs-macros v0.3.3
[INFO] [stderr]    Compiling scopegraphs v0.3.3
[INFO] [stderr]    Compiling sg-parse v0.1.0 (/opt/rustwide/workdir/sg-parse)
[INFO] [stdout] warning: variants `Num`, `Bool`, `Fun`, and `Record` are never constructed
[INFO] [stdout]   --> sg-parse/src/stlc/types.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 11 | pub enum SyntaxTypes {
[INFO] [stdout]    |          ----------- variants in this enum
[INFO] [stdout] 12 |     Num,
[INFO] [stdout]    |     ^^^
[INFO] [stdout] 13 |     Bool,
[INFO] [stdout]    |     ^^^^
[INFO] [stdout] 14 |     Fun(Box<SyntaxTypes>, Box<SyntaxTypes>),
[INFO] [stdout]    |     ^^^
[INFO] [stdout] 15 |     Record(Vec<(String, SyntaxTypes)>),
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `SyntaxTypes` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]    = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `to_stlc` is never used
[INFO] [stdout]   --> sg-parse/src/stlc/types.rs:19:12
[INFO] [stdout]    |
[INFO] [stdout] 18 | impl SyntaxTypes {
[INFO] [stdout]    | ---------------- method in this implementation
[INFO] [stdout] 19 |     pub fn to_stlc(&self, sg: &StlcGraph<'_>, prev_scope: Scope) -> StlcType {
[INFO] [stdout]    |            ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 14.74s
[INFO] running `Command { std: "docker" "inspect" "d4c007d264728881d64399eb2e202a82e592068fb0ed34af2860bf9343e7274f", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "d4c007d264728881d64399eb2e202a82e592068fb0ed34af2860bf9343e7274f", kill_on_drop: false }`
[INFO] [stdout] d4c007d264728881d64399eb2e202a82e592068fb0ed34af2860bf9343e7274f
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:f3a9d4ad9d972b27faf3965f35b62e55ba32bbce8f20bc8fe909558a86702fde" "/opt/rustwide/cargo-home/bin/cargo" "+1.83.0" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 2d4b4c409cb04aff1b48b1d4144a6eddb1c6b4329980d96af17c8935d7d20ad9
[INFO] running `Command { std: "docker" "start" "-a" "2d4b4c409cb04aff1b48b1d4144a6eddb1c6b4329980d96af17c8935d7d20ad9", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.168
[INFO] [stderr]    Compiling rustix v0.38.42
[INFO] [stderr]    Compiling linux-raw-sys v0.4.14
[INFO] [stderr]    Compiling anstyle-parse v0.2.6
[INFO] [stderr]    Compiling anstyle v1.0.10
[INFO] [stderr]    Compiling anstyle-query v1.1.2
[INFO] [stderr]    Compiling colorchoice v1.0.3
[INFO] [stderr]    Compiling scope-graph v0.1.0 (/opt/rustwide/workdir/scope-graph)
[INFO] [stdout] warning: unused import: `regex::Regex`
[INFO] [stdout]  --> scope-graph/src/scopegraph.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use regex::Regex;
[INFO] [stdout]   |     ^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `LabelRegex`
[INFO] [stdout]  --> scope-graph/src/scopegraph.rs:5:71
[INFO] [stdout]   |
[INFO] [stdout] 5 | use crate::{data::ScopeGraphData, label::ScopeGraphLabel, lbl_regex::{LabelRegex, LabelRegexMatcher}, path::Path, scope::Scope};
[INFO] [stdout]   |                                                                       ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `array::IntoIter` and `rc::Rc`
[INFO] [stdout]  --> scope-graph/src/path.rs:1:11
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{array::IntoIter, rc::Rc};
[INFO] [stdout]   |           ^^^^^^^^^^^^^^^  ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `id` is never used
[INFO] [stdout]   --> scope-graph/src/scope.rs:16:12
[INFO] [stdout]    |
[INFO] [stdout] 10 | impl Scope {
[INFO] [stdout]    | ---------- method in this implementation
[INFO] [stdout] ...
[INFO] [stdout] 16 |     pub fn id(&self) -> usize {
[INFO] [stdout]    |            ^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variants `OneOrMore` and `Or` are never constructed
[INFO] [stdout]   --> scope-graph/src/lbl_regex.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 7  | pub enum LabelRegex<Lbl: ScopeGraphLabel> {
[INFO] [stdout]    |          ---------- variants in this enum
[INFO] [stdout] ...
[INFO] [stdout] 13 |     OneOrMore(Lbl),
[INFO] [stdout]    |     ^^^^^^^^^
[INFO] [stdout] 14 |     Or(Rc<Self>, Rc<Self>),
[INFO] [stdout]    |     ^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `LabelRegex` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: associated function `or` is never used
[INFO] [stdout]   --> scope-graph/src/lbl_regex.rs:18:12
[INFO] [stdout]    |
[INFO] [stdout] 17 | impl<Lbl: ScopeGraphLabel + Clone> LabelRegex<Lbl> {
[INFO] [stdout]    | -------------------------------------------------- associated function in this implementation
[INFO] [stdout] 18 |     pub fn or(reg1: Self, reg2: Self) -> Self {
[INFO] [stdout]    |            ^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: static variable `ScopeCounter` should have an upper case name
[INFO] [stdout]  --> scope-graph/src/scope.rs:4:8
[INFO] [stdout]   |
[INFO] [stdout] 4 | static ScopeCounter: AtomicUsize = AtomicUsize::new(0);
[INFO] [stdout]   |        ^^^^^^^^^^^^ help: convert the identifier to upper case: `SCOPE_COUNTER`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_upper_case_globals)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling is-terminal v0.4.13
[INFO] [stderr]    Compiling anstream v0.3.2
[INFO] [stderr]    Compiling terminal_size v0.4.1
[INFO] [stderr]    Compiling winnow v0.6.20
[INFO] [stderr]    Compiling sclang v0.1.0 (/opt/rustwide/workdir/sclang)
[INFO] [stdout] warning: unused import: `PathBuf`
[INFO] [stdout]  --> sclang/src/expr.rs:1:34
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{io::Read, path::{Path, PathBuf}, str::FromStr};
[INFO] [stdout]   |                                  ^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `any`, `separated_pair`, `separated`, `take_until`, and `terminated`
[INFO] [stdout]  --> sclang/src/expr.rs:3:91
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t, separated, separated_pair, terminated}, error::{ParserError, StrContext, StrContextValue}, stream::{AsChar, Stream}, token::{any, take_until, t...
[INFO] [stdout]   |       ^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^                                                                                        ^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `StrContextValue`, `StrContext`, `any`, `cut_err`, `eof`, `fail`, `not`, `preceded`, `stream::AsChar`, `take_until`, `take_while`, and `terminated`
[INFO] [stdout]  --> sclang/src/types.rs:3:27
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...::{cut_err, delimited, eof, fail, not, opt, preceded, terminated}, error::{StrContext, StrContextValue}, stream::AsChar, token::{any, take_until, take_while...
[INFO] [stdout]   |       ^^^^^^^             ^^^  ^^^^  ^^^       ^^^^^^^^  ^^^^^^^^^^           ^^^^^^^^^^  ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^          ^^^  ^^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `PathBuf`
[INFO] [stdout]  --> sclang/src/expr.rs:1:34
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{io::Read, path::{Path, PathBuf}, str::FromStr};
[INFO] [stdout]   |                                  ^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `any`, `separated_pair`, `separated`, `take_until`, and `terminated`
[INFO] [stdout]  --> sclang/src/expr.rs:3:91
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t, separated, separated_pair, terminated}, error::{ParserError, StrContext, StrContextValue}, stream::{AsChar, Stream}, token::{any, take_until, t...
[INFO] [stdout]   |       ^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^                                                                                        ^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `StrContextValue`, `StrContext`, `any`, `cut_err`, `eof`, `fail`, `not`, `preceded`, `stream::AsChar`, `take_until`, `take_while`, and `terminated`
[INFO] [stdout]  --> sclang/src/types.rs:3:27
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...::{cut_err, delimited, eof, fail, not, opt, preceded, terminated}, error::{StrContext, StrContextValue}, stream::AsChar, token::{any, take_until, take_while...
[INFO] [stdout]   |       ^^^^^^^             ^^^  ^^^^  ^^^       ^^^^^^^^  ^^^^^^^^^^           ^^^^^^^^^^  ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^          ^^^  ^^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `str::FromStr`
[INFO] [stdout]   --> sclang/src/lib.rs:11:30
[INFO] [stdout]    |
[INFO] [stdout] 11 |     use std::{path::PathBuf, str::FromStr};
[INFO] [stdout]    |                              ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling sg-parse v0.1.0 (/opt/rustwide/workdir/sg-parse)
[INFO] [stdout] warning: unused variable: `t1`
[INFO] [stdout]    --> sg-parse/src/stlc/types.rs:143:13
[INFO] [stdout]     |
[INFO] [stdout] 143 |         let t1 = StlcType::Record(1);
[INFO] [stdout]     |             ^^ help: if this is intentional, prefix it with an underscore: `_t1`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `t2`
[INFO] [stdout]    --> sg-parse/src/stlc/types.rs:144:13
[INFO] [stdout]     |
[INFO] [stdout] 144 |         let t2 = StlcType::Record(2);
[INFO] [stdout]     |             ^^ help: if this is intentional, prefix it with an underscore: `_t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variants `Num`, `Bool`, `Fun`, and `Record` are never constructed
[INFO] [stdout]   --> sg-parse/src/stlc/types.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 11 | pub enum SyntaxTypes {
[INFO] [stdout]    |          ----------- variants in this enum
[INFO] [stdout] 12 |     Num,
[INFO] [stdout]    |     ^^^
[INFO] [stdout] 13 |     Bool,
[INFO] [stdout]    |     ^^^^
[INFO] [stdout] 14 |     Fun(Box<SyntaxTypes>, Box<SyntaxTypes>),
[INFO] [stdout]    |     ^^^
[INFO] [stdout] 15 |     Record(Vec<(String, SyntaxTypes)>),
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `SyntaxTypes` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]    = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `to_stlc` is never used
[INFO] [stdout]   --> sg-parse/src/stlc/types.rs:19:12
[INFO] [stdout]    |
[INFO] [stdout] 18 | impl SyntaxTypes {
[INFO] [stdout]    | ---------------- method in this implementation
[INFO] [stdout] 19 |     pub fn to_stlc(&self, sg: &StlcGraph<'_>, prev_scope: Scope) -> StlcType {
[INFO] [stdout]    |            ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 6.90s
[INFO] running `Command { std: "docker" "inspect" "2d4b4c409cb04aff1b48b1d4144a6eddb1c6b4329980d96af17c8935d7d20ad9", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "2d4b4c409cb04aff1b48b1d4144a6eddb1c6b4329980d96af17c8935d7d20ad9", kill_on_drop: false }`
[INFO] [stdout] 2d4b4c409cb04aff1b48b1d4144a6eddb1c6b4329980d96af17c8935d7d20ad9
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:f3a9d4ad9d972b27faf3965f35b62e55ba32bbce8f20bc8fe909558a86702fde" "/opt/rustwide/cargo-home/bin/cargo" "+1.83.0" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] addb59aa6246143f59b3d0b0ec3b4458c13a2333a1218af7ab66d84f5d07b667
[INFO] running `Command { std: "docker" "start" "-a" "addb59aa6246143f59b3d0b0ec3b4458c13a2333a1218af7ab66d84f5d07b667", kill_on_drop: false }`
[INFO] [stderr] warning: unused import: `PathBuf`
[INFO] [stderr]  --> sclang/src/expr.rs:1:34
[INFO] [stderr]   |
[INFO] [stderr] 1 | use std::{io::Read, path::{Path, PathBuf}, str::FromStr};
[INFO] [stderr]   |                                  ^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused imports: `any`, `separated_pair`, `separated`, `take_until`, and `terminated`
[INFO] [stderr]  --> sclang/src/expr.rs:3:91
[INFO] [stderr]   |
[INFO] [stderr] 3 | ...t, separated, separated_pair, terminated}, error::{ParserError, StrContext, StrContextValue}, stream::{AsChar, Stream}, token::{any, take_until, t...
[INFO] [stderr]   |       ^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^                                                                                        ^^^  ^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused imports: `StrContextValue`, `StrContext`, `any`, `cut_err`, `eof`, `fail`, `not`, `preceded`, `stream::AsChar`, `take_until`, `take_while`, and `terminated`
[INFO] [stderr]  --> sclang/src/types.rs:3:27
[INFO] [stderr]   |
[INFO] [stderr] 3 | ...::{cut_err, delimited, eof, fail, not, opt, preceded, terminated}, error::{StrContext, StrContextValue}, stream::AsChar, token::{any, take_until, take_while...
[INFO] [stderr]   |       ^^^^^^^             ^^^  ^^^^  ^^^       ^^^^^^^^  ^^^^^^^^^^           ^^^^^^^^^^  ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^          ^^^  ^^^^^^^^^^  ^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: `sclang` (lib) generated 3 warnings (run `cargo fix --lib -p sclang` to apply 3 suggestions)
[INFO] [stderr] warning: unused import: `str::FromStr`
[INFO] [stderr]   --> sclang/src/lib.rs:11:30
[INFO] [stderr]    |
[INFO] [stderr] 11 |     use std::{path::PathBuf, str::FromStr};
[INFO] [stderr]    |                              ^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: `sclang` (lib test) generated 4 warnings (3 duplicates) (run `cargo fix --lib -p sclang --tests` to apply 1 suggestion)
[INFO] [stderr] warning: unused import: `regex::Regex`
[INFO] [stderr]  --> scope-graph/src/scopegraph.rs:3:5
[INFO] [stderr]   |
[INFO] [stderr] 3 | use regex::Regex;
[INFO] [stderr]   |     ^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `LabelRegex`
[INFO] [stderr]  --> scope-graph/src/scopegraph.rs:5:71
[INFO] [stderr]   |
[INFO] [stderr] 5 | use crate::{data::ScopeGraphData, label::ScopeGraphLabel, lbl_regex::{LabelRegex, LabelRegexMatcher}, path::Path, scope::Scope};
[INFO] [stderr]   |                                                                       ^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused imports: `array::IntoIter` and `rc::Rc`
[INFO] [stderr]  --> scope-graph/src/path.rs:1:11
[INFO] [stderr]   |
[INFO] [stderr] 1 | use std::{array::IntoIter, rc::Rc};
[INFO] [stderr]   |           ^^^^^^^^^^^^^^^  ^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: method `id` is never used
[INFO] [stderr]   --> scope-graph/src/scope.rs:16:12
[INFO] [stderr]    |
[INFO] [stderr] 10 | impl Scope {
[INFO] [stderr]    | ---------- method in this implementation
[INFO] [stderr] ...
[INFO] [stderr] 16 |     pub fn id(&self) -> usize {
[INFO] [stderr]    |            ^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: variants `OneOrMore` and `Or` are never constructed
[INFO] [stderr]   --> scope-graph/src/lbl_regex.rs:13:5
[INFO] [stderr]    |
[INFO] [stderr] 7  | pub enum LabelRegex<Lbl: ScopeGraphLabel> {
[INFO] [stderr]    |          ---------- variants in this enum
[INFO] [stderr] ...
[INFO] [stderr] 13 |     OneOrMore(Lbl),
[INFO] [stderr]    |     ^^^^^^^^^
[INFO] [stderr] 14 |     Or(Rc<Self>, Rc<Self>),
[INFO] [stderr]    |     ^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `LabelRegex` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
[INFO] [stderr] 
[INFO] [stderr] warning: associated function `or` is never used
[INFO] [stderr]   --> scope-graph/src/lbl_regex.rs:18:12
[INFO] [stderr]    |
[INFO] [stderr] 17 | impl<Lbl: ScopeGraphLabel + Clone> LabelRegex<Lbl> {
[INFO] [stderr]    | -------------------------------------------------- associated function in this implementation
[INFO] [stderr] 18 |     pub fn or(reg1: Self, reg2: Self) -> Self {
[INFO] [stderr]    |            ^^
[INFO] [stderr] 
[INFO] [stderr] warning: static variable `ScopeCounter` should have an upper case name
[INFO] [stderr]  --> scope-graph/src/scope.rs:4:8
[INFO] [stderr]   |
[INFO] [stderr] 4 | static ScopeCounter: AtomicUsize = AtomicUsize::new(0);
[INFO] [stderr]   |        ^^^^^^^^^^^^ help: convert the identifier to upper case: `SCOPE_COUNTER`
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(non_upper_case_globals)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `scope-graph` (bin "scope-graph" test) generated 7 warnings (run `cargo fix --bin "scope-graph" --tests` to apply 3 suggestions)
[INFO] [stderr] warning: unused variable: `t1`
[INFO] [stderr]    --> sg-parse/src/stlc/types.rs:143:13
[INFO] [stderr]     |
[INFO] [stderr] 143 |         let t1 = StlcType::Record(1);
[INFO] [stderr]     |             ^^ help: if this is intentional, prefix it with an underscore: `_t1`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_variables)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `t2`
[INFO] [stderr]    --> sg-parse/src/stlc/types.rs:144:13
[INFO] [stderr]     |
[INFO] [stderr] 144 |         let t2 = StlcType::Record(2);
[INFO] [stderr]     |             ^^ help: if this is intentional, prefix it with an underscore: `_t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variants `Num`, `Bool`, `Fun`, and `Record` are never constructed
[INFO] [stderr]   --> sg-parse/src/stlc/types.rs:12:5
[INFO] [stderr]    |
[INFO] [stderr] 11 | pub enum SyntaxTypes {
[INFO] [stderr]    |          ----------- variants in this enum
[INFO] [stderr] 12 |     Num,
[INFO] [stderr]    |     ^^^
[INFO] [stderr] 13 |     Bool,
[INFO] [stderr]    |     ^^^^
[INFO] [stderr] 14 |     Fun(Box<SyntaxTypes>, Box<SyntaxTypes>),
[INFO] [stderr]    |     ^^^
[INFO] [stderr] 15 |     Record(Vec<(String, SyntaxTypes)>),
[INFO] [stderr]    |     ^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `SyntaxTypes` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stderr]    = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: method `to_stlc` is never used
[INFO] [stderr]   --> sg-parse/src/stlc/types.rs:19:12
[INFO] [stderr]    |
[INFO] [stderr] 18 | impl SyntaxTypes {
[INFO] [stderr]    | ---------------- method in this implementation
[INFO] [stderr] 19 |     pub fn to_stlc(&self, sg: &StlcGraph<'_>, prev_scope: Scope) -> StlcType {
[INFO] [stderr]    |            ^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: `sg-parse` (bin "sg-parse" test) generated 4 warnings
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.10s
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/sclang-d2267804ee664efe)
[INFO] [stdout] 
[INFO] [stdout] running 12 tests
[INFO] [stderr] > delimited                                         | "1 + 2"∅
[INFO] [stderr]   > multispace0                                     | "1 + 2"∅
[INFO] [stderr]    > take_while                                     | "1 + 2"∅
[INFO] [stderr]    < take_while                                     | +0
[INFO] [stderr]   < multispace0                                     | +0
[INFO] [stderr]         > preceded                                  | "1 + 2"∅
[INFO] [stderr]          > multispace0                              | "1 + 2"∅
[INFO] [stderr]           > take_while                              | "1 + 2"∅
[INFO] [stderr]           < take_while                              | +0
[INFO] [stderr]          < multispace0                              | +0
[INFO] [stderr]          > alt                                      | "1 + 2"∅
[INFO] [stderr]           > preceded                                | "1 + 2"∅
[INFO] [stderr]            > multispace0                            | "1 + 2"∅
[INFO] [stderr]             > take_while                            | "1 + 2"∅
[INFO] [stderr]             < take_while                            | +0
[INFO] [stderr]     > delimited                                     | "let r = {x = 3, y = fals
[INFO] [stderr]             > multispace0                           | "let r = {x = 3, y = fals
[INFO] [stderr]     > delimited                                     | "add(1)"∅
[INFO] [stderr]      > delimited                                    | "1234567890"∅
[INFO] [stderr]                 > multispace0                       | "1234567890"∅
[INFO] [stderr]                  > take_while                       | "1234567890"∅
[INFO] [stderr]                  < take_while                       | +0
[INFO] [stderr]                 < multispace0                       | +0
[INFO] [stderr]                 > preceded                          | "1234567890"∅
[INFO] [stderr]                   > multispace0                     | "1234567890"∅
[INFO] [stderr]                    > take_while                     | "1234567890"∅
[INFO] [stderr]                    < take_while                     | +0
[INFO] [stderr]                   < multispace0                     | +0
[INFO] [stderr]                   > alt                             | "1234567890"∅
[INFO] [stderr]                    > preceded                       | "1234567890"∅
[INFO] [stderr]                     > multispace0                   | "1234567890"∅
[INFO] [stderr]                      > take_while                   | "1234567890"∅
[INFO] [stderr]                      < take_while                   | +0
[INFO] [stderr]                     < multispace0                   | +0
[INFO] [stderr]                     > alt                           | "1234567890"∅
[INFO] [stderr]                      > Self :: Add                  | "1234567890"∅
[INFO] [stderr]                       > preceded                    | "1234567890"∅
[INFO] [stderr]                        > multispace0                | "1234567890"∅
[INFO] [stderr]                         > take_while                | "1234567890"∅
[INFO] [stderr]                         < take_while                | +0
[INFO] [stderr]                        < multispace0                | +0
[INFO] [stderr]                        > alt                        | "1234567890"∅
[INFO] [stderr]                         > Self :: Let               | "1234567890"∅
[INFO] [stderr]                          > "let"                    | "1234567890"∅
[INFO] [stderr]                          < "let"                    | backtrack
[INFO] [stderr]                         < Self :: Let               | backtrack
[INFO] [stderr]                         > Self :: Func              | "1234567890"∅
[INFO] [stderr]                          > "fun"                    | "1234567890"∅
[INFO] [stderr]                          < "fun"                    | backtrack
[INFO] [stderr]                         < Self :: Func              | backtrack
[INFO] [stderr]                           > Label("record")         | "1234567890"∅
[INFO] [stderr]                            > delimited              | "1234567890"∅
[INFO] [stderr]  > delimited                                        | "true"∅
[INFO] [stderr]                              > multispace0          | "true"∅
[INFO] [stderr]                               > take_while          | "true"∅
[INFO] [stderr]                               < take_while          | +0
[INFO] [stderr]                              < multispace0          | +0
[INFO] [stderr]                              > preceded             | "true"∅
[INFO] [stderr]                               > multispace0         | "true"∅
[INFO] [stderr]                                > take_while         | "true"∅
[INFO] [stderr]                                < take_while         | +0
[INFO] [stderr]                               < multispace0         | +0
[INFO] [stderr]                               > alt                 | "true"∅
[INFO] [stderr]                                > preceded           | "true"∅
[INFO] [stderr]                                 > multispace0       | "true"∅
[INFO] [stderr]                                  > take_while       | "true"∅
[INFO] [stderr]                                  < take_while       | +0
[INFO] [stderr]                                 < multispace0       | +0
[INFO] [stderr]                                 > alt               | "true"∅
[INFO] [stderr]                                  > Self :: Add      | "true"∅
[INFO] [stderr]                                   > preceded        | "true"∅
[INFO] [stderr]                                    > multispace0    | "true"∅
[INFO] [stderr]                                     > take_while    | "true"∅
[INFO] [stderr]                                     < take_while    | +0
[INFO] [stderr]                                    < multispace0    | +0
[INFO] [stderr]                                    > alt            | "true"∅
[INFO] [stderr]                                     > Self :: Let   | "true"∅
[INFO] [stderr]                                      > "let"        | "true"∅
[INFO] [stderr]                                      < "let"        | backtrack
[INFO] [stderr]                                     < Self :: Let   | backtrack
[INFO] [stderr]                                     > Self :: Func  | "true"∅
[INFO] [stderr]                             > multispace0           | "1234567890"∅
[INFO] [stderr]              > take_while                           | "let r = {x = 3, y = fals
[INFO] [stderr]              < take_while                           | +0
[INFO] [stderr]                > multispace0                        | "add(1)"∅
[INFO] [stderr]                                        > take_while | "add(1)"∅
[INFO] [stderr]                                        < take_while | +0
[INFO] [stderr]                < multispace0                        | +0
[INFO] [stderr]                                       > preceded    | "add(1)"∅
[INFO] [stderr]                                        > multispace0 | "add(1)"∅
[INFO] [stderr]                                         > take_while | "add(1)"∅
[INFO] [stderr]                                         < take_while | +0
[INFO] [stderr]                                        < multispace0 | +0
[INFO] [stderr]                                        > alt        | "add(1)"∅
[INFO] [stderr]                                         > preceded  | "add(1)"∅
[INFO] [stderr]                                          > multispace0 | "add(1)"∅
[INFO] [stderr]                                           > take_while | "add(1)"∅
[INFO] [stderr]                                           < take_while | +0
[INFO] [stderr]                                          < multispace0 | +0
[INFO] [stderr]                                          > alt      | "add(1)"∅
[INFO] [stderr]                                           > Self :: Add | "add(1)"∅
[INFO] [stderr]                                            > preceded | "add(1)"∅
[INFO] [stderr]                                             > multispace0 | "add(1)"∅
[INFO] [stderr]                                              > take_while | "add(1)"∅
[INFO] [stderr]                                              < take_while | +0
[INFO] [stderr]                                             < multispace0 | +0
[INFO] [stderr]                                             > alt   | "add(1)"∅
[INFO] [stderr]                                              > Self :: Let | "add(1)"∅
[INFO] [stderr]                                               > "let" | "add(1)"∅
[INFO] [stderr]                                               < "let" | backtrack
[INFO] [stderr]                                              < Self :: Let | backtrack
[INFO] [stderr]                                              > Self :: Func | "add(1)"∅
[INFO] [stderr]                                               > "fun" | "add(1)"∅
[INFO] [stderr]                                               < "fun" | backtrack
[INFO] [stderr]                                              < Self :: Func | backtrack
[INFO] [stderr]                                              > Label("record") | "add(1)"∅
[INFO] [stderr]                                               > delimited | "add(1)"∅
[INFO] [stderr]                                                > multispace0 | "add(1)"∅
[INFO] [stderr]                                                 > take_while | "add(1)"∅
[INFO] [stderr]                                                 < take_while | +0
[INFO] [stderr]                                                < multispace0 | +0
[INFO] [stderr]                                                > '{' | "add(1)"∅
[INFO] [stderr]                                                < '{' | backtrack
[INFO] [stderr]                                               < delimited | backtrack
[INFO] [stderr]                                              < Label("record") | backtrack
[INFO] [stderr]                                              > Self :: With | "add(1)"∅
[INFO] [stderr]                                               > "with" | "add(1)"∅
[INFO] [stderr]                                               < "with" | backtrack
[INFO] [stderr]                                              < Self :: With | backtrack
[INFO] [stderr]                                              > preceded | "add(1)"∅
[INFO] [stderr]                                               > multispace0 | "add(1)"∅
[INFO] [stderr]                                                > take_while | "add(1)"∅
[INFO] [stderr]                                                < take_while | +0
[INFO] [stderr]                                               < multispace0 | +0
[INFO] [stderr]                                               > alt | "add(1)"∅
[INFO] [stderr]                                                > not | "add(1)"∅
[INFO] [stderr]                                                 > alt | "add(1)"∅
[INFO] [stderr]                                                  > "let" | "add(1)"∅
[INFO] [stderr]                                                  < "let" | backtrack
[INFO] [stderr]                                                  > "if" | "add(1)"∅
[INFO] [stderr]                                                  < "if" | backtrack
[INFO] [stderr]                                                  > "else" | "add(1)"∅
[INFO] [stderr]                                                  < "else" | backtrack
[INFO] [stderr]                                                  > "while" | "add(1)"∅
[INFO] [stderr]                                                  < "while" | backtrack
[INFO] [stderr]                                                  > "return" | "add(1)"∅
[INFO] [stderr]                                                  < "return" | backtrack
[INFO] [stderr]                                                  > "break" | "add(1)"∅
[INFO] [stderr]                                                  < "break" | backtrack
[INFO] [stderr]                                                  > "continue" | "add(1)"∅
[INFO] [stderr]                                                  < "continue" | backtrack
[INFO] [stderr]                                                  > "fun" | "add(1)"∅
[INFO] [stderr]                                                  < "fun" | backtrack
[INFO] [stderr]                                                  > "true" | "add(1)"∅
[INFO] [stderr]                                                  < "true" | backtrack
[INFO] [stderr]                                                  > "false" | "add(1)"∅
[INFO] [stderr]                                                  < "false" | backtrack
[INFO] [stderr]                                                 < alt | backtrack
[INFO] [stderr]                                                < not | +0
[INFO] [stderr]                                               > Label("variable") | "add(1)"∅
[INFO] [stderr]                                                > alpha1 | "add(1)"∅
[INFO] [stderr]                                                 > take_while | "add(1)"∅
[INFO] [stderr]                                                 < take_while | +3
[INFO] [stderr]                                                < alpha1 | +3
[INFO] [stderr]            < multispace0                            | +0
[INFO] [stderr]                                                > alt | "1 + 2"∅
[INFO] [stderr]                                                 > Self :: Add | "1 + 2"∅
[INFO] [stderr]                                                  > preceded | "1 + 2"∅
[INFO] [stderr]                                                   > multispace0 | "1 + 2"∅
[INFO] [stderr]                                                    > take_while | "1 + 2"∅
[INFO] [stderr]                                                    < take_while | +0
[INFO] [stderr]             < multispace0                           | +0
[INFO] [stderr]                                                    > preceded | "let r = {x = 3, y = fals
[INFO] [stderr]                                                     > multispace0 | "let r = {x = 3, y = fals
[INFO] [stderr]                                                      > take_while | "let r = {x = 3, y = fals
[INFO] [stderr]                                                      < take_while | +0
[INFO] [stderr]                                                     < multispace0 | +0
[INFO] [stderr]                                                     > alt | "let r = {x = 3, y = fals
[INFO] [stderr]                                                      > preceded | "let r = {x = 3, y = fals
[INFO] [stderr]                                                       > multispace0 | "let r = {x = 3, y = fals
[INFO] [stderr]                                                        > take_while | "let r = {x = 3, y = fals
[INFO] [stderr]                                                        < take_while | +0
[INFO] [stderr]                                                       < multispace0 | +0
[INFO] [stderr]                                                       > alt | "let r = {x = 3, y = fals
[INFO] [stderr]                                                        > Self :: Add | "let r = {x = 3, y = fals
[INFO] [stderr]                                                         > preceded | "let r = {x = 3, y = fals
[INFO] [stderr]                                                          > multispace0 | "let r = {x = 3, y = fals
[INFO] [stderr]                                                           > take_while | "let r = {x = 3, y = fals
[INFO] [stderr]                                                           < take_while | +0
[INFO] [stderr]                                                          < multispace0 | +0
[INFO] [stderr]                                                          > alt | "let r = {x = 3, y = fals
[INFO] [stderr]                                                           > Self :: Let | "let r = {x = 3, y = fals
[INFO] [stderr]                                                            > "let" | "let r = {x = 3, y = fals
[INFO] [stderr]                                                            < "let" | +3
[INFO] [stderr]                                                            > space1 | " r = {x = 3, y = false, 
[INFO] [stderr]                                                             > take_while | " r = {x = 3, y = false, 
[INFO] [stderr]                                                             < take_while | +1
[INFO] [stderr]                                                            < space1 | +1
[INFO] [stderr]                                                            > not | "r = {x = 3, y = false, z
[INFO] [stderr]                                                             > alt | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              > "let" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "let" | backtrack
[INFO] [stderr]                                                              > "if" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "if" | backtrack
[INFO] [stderr]                                                              > "else" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "else" | backtrack
[INFO] [stderr]                                                              > "while" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "while" | backtrack
[INFO] [stderr]                                                              > "return" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "return" | backtrack
[INFO] [stderr]                                                              > "break" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "break" | backtrack
[INFO] [stderr]                                                              > "continue" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "continue" | backtrack
[INFO] [stderr]                                                              > "fun" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "fun" | backtrack
[INFO] [stderr]                                                              > "true" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "true" | backtrack
[INFO] [stderr]                                                              > "false" | "r = {x = 3, y = false, z
[INFO] [stderr]                                                              < "false" | backtrack
[INFO] [stderr]                                                             < alt | backtrack
[INFO] [stderr]                                                            < not | +0
[INFO] [stderr]                                                            > Label("variable") | "r = {x = 3, y = false, z
[INFO] [stderr]                                                             > alpha1 | "r = {x = 3, y = false, z
[INFO] [stderr]                                                             > take_while | "r = {x = 3, y = false, z
[INFO] [stderr]         > delimited                                 | "let x = fun(x: number) {
[INFO] [stderr]                                                              > multispace0 | "let x = fun(x: number) {
[INFO] [stderr]                                                               > take_while | "let x = fun(x: number) {
[INFO] [stderr]                                                               < take_while | +0
[INFO] [stderr]                                                              < multispace0 | +0
[INFO] [stderr]                                                              > preceded | "let x = fun(x: number) {
[INFO] [stderr]                                                               > multispace0 | "let x = fun(x: number) {
[INFO] [stderr]                                                                > take_while | "let x = fun(x: number) {
[INFO] [stderr]                                                                < take_while | +0
[INFO] [stderr]                                                               < multispace0 | +0
[INFO] [stderr]                                                               > alt | "let x = fun(x: number) {
[INFO] [stderr]                                                                > preceded | "let x = fun(x: number) {
[INFO] [stderr]                                                                 > multispace0 | "let x = fun(x: number) {
[INFO] [stderr]                                                                  > take_while | "let x = fun(x: number) {
[INFO] [stderr]                                                                  < take_while | +0
[INFO] [stderr]                                                                 < multispace0 | +0
[INFO] [stderr]                                                                 > alt | "let x = fun(x: number) {
[INFO] [stderr]                                                                  > Self :: Add | "let x = fun(x: number) {
[INFO] [stderr]                                                                   > preceded | "let x = fun(x: number) {
[INFO] [stderr]                                                                    > multispace0 | "let x = fun(x: number) {
[INFO] [stderr]                                                                     > take_while | "let x = fun(x: number) {
[INFO] [stderr]                                                                     < take_while | +0
[INFO] [stderr]                                                                    < multispace0 | +0
[INFO] [stderr]                                                                    > alt | "let x = fun(x: number) {
[INFO] [stderr]                                                                     > Self :: Let | "let x = fun(x: number) {
[INFO] [stderr]                                                                      > "let" | "let x = fun(x: number) {
[INFO] [stderr]                                                                      < "let" | +3
[INFO] [stderr]                                                                      > space1 | " x = fun(x: number) { x 
[INFO] [stderr]                                                                       > take_while | " x = fun(x: number) { x 
[INFO] [stderr]                                                                       < take_while | +1
[INFO] [stderr]                                                                      < space1 | +1
[INFO] [stderr]                                                                      > not | "x = fun(x: number) { x +
[INFO] [stderr]                                                                       > alt | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        > "let" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "let" | backtrack
[INFO] [stderr]                                                                        > "if" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "if" | backtrack
[INFO] [stderr]                                                                        > "else" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "else" | backtrack
[INFO] [stderr]                                                                        > "while" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "while" | backtrack
[INFO] [stderr]                                                                        > "return" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "return" | backtrack
[INFO] [stderr]                                                                        > "break" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "break" | backtrack
[INFO] [stderr]                                                                        > "continue" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                        > "fun" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                        > "true" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "true" | backtrack
[INFO] [stderr]                                                                        > "false" | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        < "false" | backtrack
[INFO] [stderr]                                                                       < alt | backtrack
[INFO] [stderr]                                                                      < not | +0
[INFO] [stderr]                                                                      > Label("variable") | "x = fun(x: number) { x +
[INFO] [stderr]                                                                       > alpha1 | "x = fun(x: number) { x +
[INFO] [stderr]                                                                        > take_while | "x = fun(x: number) { x +
[INFO] [stderr]                                      > "fun"        | "true"∅
[INFO] [stderr]                                      < "fun"        | backtrack
[INFO] [stderr]                                     < Self :: Func  | backtrack
[INFO] [stderr]                                                                       > Label("record") | "true"∅
[INFO] [stderr]                                                                        > delimited | "true"∅
[INFO] [stderr]                                                                         > multispace0 | "true"∅
[INFO] [stderr]                                                                          > take_while | "true"∅
[INFO] [stderr]                                                                          < take_while | +0
[INFO] [stderr]                                                                         < multispace0 | +0
[INFO] [stderr]                                                                         > '{' | "true"∅
[INFO] [stderr]                                                                         < '{' | backtrack
[INFO] [stderr]                                                                        < delimited | backtrack
[INFO] [stderr]                                                                       < Label("record") | backtrack
[INFO] [stderr]                                                   < multispace0 | +0
[INFO] [stderr]                                                                       > alt | "1 + 2"∅
[INFO] [stderr]                                                                        > Self :: Let | "1 + 2"∅
[INFO] [stderr]                                                                         > "let" | "1 + 2"∅
[INFO] [stderr]                                                                         < "let" | backtrack
[INFO] [stderr]                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                        > Self :: Func | "1 + 2"∅
[INFO] [stderr]                                                                         > "fun" | "1 + 2"∅
[INFO] [stderr]                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                        > Label("record") | "1 + 2"∅
[INFO] [stderr]                                                                         > delimited | "1 + 2"∅
[INFO] [stderr]                                                                          > multispace0 | "1 + 2"∅
[INFO] [stderr]                                                                           > take_while | "1 + 2"∅
[INFO] [stderr]                                                                           < take_while | +0
[INFO] [stderr]                                                                          < multispace0 | +0
[INFO] [stderr]                                                                          > '{' | "1 + 2"∅
[INFO] [stderr]                                                                          < '{' | backtrack
[INFO] [stderr]                                                                         < delimited | backtrack
[INFO] [stderr]                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                        > Self :: With | "1 + 2"∅
[INFO] [stderr]                                                                         > "with" | "1 + 2"∅
[INFO] [stderr]                                                                         < "with" | backtrack
[INFO] [stderr]                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                        > preceded | "1 + 2"∅
[INFO] [stderr]                                                                         > multispace0 | "1 + 2"∅
[INFO] [stderr]                                                                          > take_while | "1 + 2"∅
[INFO] [stderr]                                                                          < take_while | +0
[INFO] [stderr]                                                                         < multispace0 | +0
[INFO] [stderr]                                                                         > alt | "1 + 2"∅
[INFO] [stderr]                                                                          > not | "1 + 2"∅
[INFO] [stderr]                                                                           > alt | "1 + 2"∅
[INFO] [stderr]                                                                            > "let" | "1 + 2"∅
[INFO] [stderr]                                                                            < "let" | backtrack
[INFO] [stderr]                                                                            > "if" | "1 + 2"∅
[INFO] [stderr]                                                                            < "if" | backtrack
[INFO] [stderr]                                                                            > "else" | "1 + 2"∅
[INFO] [stderr]                                                                            < "else" | backtrack
[INFO] [stderr]                                                                            > "while" | "1 + 2"∅
[INFO] [stderr]                                                                            < "while" | backtrack
[INFO] [stderr]                                                                            > "return" | "1 + 2"∅
[INFO] [stderr]                                                                            < "return" | backtrack
[INFO] [stderr]                                                                            > "break" | "1 + 2"∅
[INFO] [stderr]                                                                            < "break" | backtrack
[INFO] [stderr]                                                                            > "continue" | "1 + 2"∅
[INFO] [stderr]                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                            > "fun" | "1 + 2"∅
[INFO] [stderr]                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                            > "true" | "1 + 2"∅
[INFO] [stderr]                                                                            < "true" | backtrack
[INFO] [stderr]                                                                            > "false" | "1 + 2"∅
[INFO] [stderr]                                                                            < "false" | backtrack
[INFO] [stderr]                                                                           < alt | backtrack
[INFO] [stderr]                                                                          < not | +0
[INFO] [stderr]                                                                          > Label("variable") | "1 + 2"∅
[INFO] [stderr]                                                                           > alpha1 | "1 + 2"∅
[INFO] [stderr]                                                                            > take_while | "1 + 2"∅
[INFO] [stderr]                                                                            < take_while | backtrack
[INFO] [stderr]                                                                           < alpha1 | backtrack
[INFO] [stderr]                                                                          < Label("variable") | backtrack
[INFO] [stderr]                                                                          > Expected(Description("number")) | "1 + 2"∅
[INFO] [stderr]                                                                           > Label("literal") | "1 + 2"∅
[INFO] [stderr]                                                                            > digit1 | "1 + 2"∅
[INFO] [stderr]                                                                             > take_while | "1 + 2"∅
[INFO] [stderr]                                                                             < take_while | +1
[INFO] [stderr]                                                                            < digit1 | +1
[INFO] [stderr]                                                                            | verify | 
[INFO] [stderr]                                                                           < Label("literal") | +1
[INFO] [stderr]                                                                          < Expected(Description("number")) | +1
[INFO] [stderr]                                                                         < alt | +1
[INFO] [stderr]                                                                        < preceded | +1
[INFO] [stderr]                                                                       < alt | +1
[INFO] [stderr]                                                  < preceded | +1
[INFO] [stderr]                                                                      > multispace0 | " + 2"∅
[INFO] [stderr]                                                                       > take_while | " + 2"∅
[INFO] [stderr]                                                             < take_while | +1
[INFO] [stderr]                                                             < alpha1 | +1
[INFO] [stderr]                                                                      > take_while | " = {x = 3, y = false, z 
[INFO] [stderr]                                                                      < take_while | +0
[INFO] [stderr]                                                            < Label("variable") | +1
[INFO] [stderr]                                                                     > space0 | " = {x = 3, y = false, z 
[INFO] [stderr]                                                                      > take_while | " = {x = 3, y = false, z 
[INFO] [stderr]                                                                      < take_while | +1
[INFO] [stderr]                                                                     < space0 | +1
[INFO] [stderr]                                                                     > '=' | "= {x = 3, y = false, z =
[INFO] [stderr]                                                                     < '=' | +1
[INFO] [stderr]                                                                     > space0 | " {x = 3, y = false, z = 
[INFO] [stderr]                                                                      > take_while | " {x = 3, y = false, z = 
[INFO] [stderr]                                                                      < take_while | +1
[INFO] [stderr]                                                                     < space0 | +1
[INFO] [stderr]                                                                     > cut_err | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                      > Expected(Description("expression")) | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                       > Label("body expression") | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                        > preceded | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                         > multispace0 | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                          > take_while | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                          < take_while | +0
[INFO] [stderr]                                                                         < multispace0 | +0
[INFO] [stderr]                                                                         > alt | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                          > preceded | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                           > multispace0 | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                            > take_while | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                            < take_while | +0
[INFO] [stderr]                                                                           < multispace0 | +0
[INFO] [stderr]                                                                           > alt | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                            > Self :: Add | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                             > preceded | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                              > multispace0 | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                               > take_while | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                               < take_while | +0
[INFO] [stderr]                                                                              < multispace0 | +0
[INFO] [stderr]                                                                              > alt | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                               > Self :: Let | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                > "let" | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                < "let" | backtrack
[INFO] [stderr]                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                               > Self :: Func | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                > "fun" | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                               > Label("record") | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                > delimited | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                 > multispace0 | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                  > take_while | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                  < take_while | +0
[INFO] [stderr]                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                 > '{' | "{x = 3, y = false, z = 5
[INFO] [stderr]                                                                                 < '{' | +1
[INFO] [stderr]                                                                                 > multispace0 | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                  > take_while | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                  < take_while | +0
[INFO] [stderr]                                                                                 < multispace0 | +0
[INFO] [stderr]                                       > take_while  | "1234567890"∅
[INFO] [stderr]                                       < take_while  | +0
[INFO] [stderr]                  > delimited                        | "x"∅
[INFO] [stderr]                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                   < take_while | +0
[INFO] [stderr]                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                  > preceded | "x"∅
[INFO] [stderr]                                                                                   > multispace0 | "x"∅
[INFO] [stderr]                                                                                    > take_while | "x"∅
[INFO] [stderr]                                                                                    < take_while | +0
[INFO] [stderr]                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                   > alt | "x"∅
[INFO] [stderr]                                                                                    > preceded | "x"∅
[INFO] [stderr]                                                                                     > multispace0 | "x"∅
[INFO] [stderr]                                                                                      > take_while | "x"∅
[INFO] [stderr]                                                                                      < take_while | +0
[INFO] [stderr]                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                     > alt | "x"∅
[INFO] [stderr]                                                                                      > Self :: Add | "x"∅
[INFO] [stderr]                                                                                       > preceded | "x"∅
[INFO] [stderr]                                                                                        > multispace0 | "x"∅
[INFO] [stderr]                                                                                         > take_while | "x"∅
[INFO] [stderr]                                                                                         < take_while | +0
[INFO] [stderr]                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                        > alt | "x"∅
[INFO] [stderr]                                                                                         > Self :: Let | "x"∅
[INFO] [stderr]                                                                                          > "let" | "x"∅
[INFO] [stderr]                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                         < Self :: Let | backtrack
[INFO] [stderr]                                                                                         > Self :: Func | "x"∅
[INFO] [stderr]                                                                                          > "fun" | "x"∅
[INFO] [stderr]                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                         < Self :: Func | backtrack
[INFO] [stderr]                                                                                         > Label("record") | "x"∅
[INFO] [stderr]                                                                                          > delimited | "x"∅
[INFO] [stderr]                                                                                           > multispace0 | "x"∅
[INFO] [stderr]                                                                                            > take_while | "x"∅
[INFO] [stderr]                                                                                            < take_while | +0
[INFO] [stderr]                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                           > '{' | "x"∅
[INFO] [stderr]                                                                                           < '{' | backtrack
[INFO] [stderr]                                                                                          < delimited | backtrack
[INFO] [stderr]                                                                                         < Label("record") | backtrack
[INFO] [stderr]                                                                                         > Self :: With | "x"∅
[INFO] [stderr]                                                                                          > "with" | "x"∅
[INFO] [stderr]                                                                                          < "with" | backtrack
[INFO] [stderr]                                                                                         < Self :: With | backtrack
[INFO] [stderr]                                                                                         > preceded | "x"∅
[INFO] [stderr]                                                                                          > multispace0 | "x"∅
[INFO] [stderr]                                                                                           > take_while | "x"∅
[INFO] [stderr]                                                                                           < take_while | +0
[INFO] [stderr]                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                          > alt | "x"∅
[INFO] [stderr]                                                                                           > not | "x"∅
[INFO] [stderr]                                                                                            > alt | "x"∅
[INFO] [stderr]                                                                                             > "let" | "x"∅
[INFO] [stderr]                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                             > "if" | "x"∅
[INFO] [stderr]                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                            > "else" | "x"∅
[INFO] [stderr]                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                            > "while" | "x"∅
[INFO] [stderr]                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                            > "return" | "x"∅
[INFO] [stderr]                                                                                            < "return" | backtrack
[INFO] [stderr]               > delimited                           | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                             > multispace0 | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                              > take_while | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                              < take_while | +0
[INFO] [stderr]                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                             > preceded | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                              > multispace0 | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                               > take_while | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                               < take_while | +0
[INFO] [stderr]                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                              > alt | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                               > preceded | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                > multispace0 | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                 > take_while | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                > alt | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                 > Self :: Add | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                  > preceded | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                   > multispace0 | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                    > take_while | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                    < take_while | +0
[INFO] [stderr]                             < multispace0           | +0
[INFO] [stderr]                                                                                                    > '{' | "1234567890"∅
[INFO] [stderr]                                                                                                    < '{' | backtrack
[INFO] [stderr]                            < delimited              | backtrack
[INFO] [stderr]                           < Label("record")         | backtrack
[INFO] [stderr]                                                                                                  > Self :: With | "1234567890"∅
[INFO] [stderr]                                                                                                   > "with" | "1234567890"∅
[INFO] [stderr]                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                  > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                   > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                    > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                   > alt | "1234567890"∅
[INFO] [stderr]                                                                                                    > not | "1234567890"∅
[INFO] [stderr]                                                                                                     > alt | "1234567890"∅
[INFO] [stderr]                                                                                                      > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                      > "if" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                      > "else" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                      > "while" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                      > "return" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                      > "break" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                      > "continue" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "continue" | backtrack
[INFO] [stderr]                                                                                                      > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                      > "true" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                      > "false" | "1234567890"∅
[INFO] [stderr]                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                    < not | +0
[INFO] [stderr]                                                                                                    > Label("variable") | "1234567890"∅
[INFO] [stderr]                                                                                                     > alpha1 | "1234567890"∅
[INFO] [stderr]                                                                                                      > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                      < take_while | backtrack
[INFO] [stderr]                                                                                                     < alpha1 | backtrack
[INFO] [stderr]                                                                                                    < Label("variable") | backtrack
[INFO] [stderr]                                                                                                    > Expected(Description("number")) | "1234567890"∅
[INFO] [stderr]                                                                                                     > Label("literal") | "1234567890"∅
[INFO] [stderr]                                                                                                      > digit1 | "1234567890"∅
[INFO] [stderr]                                                                                                       > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                       < take_while | +10
[INFO] [stderr]                                                                                                      < digit1 | +10
[INFO] [stderr]                                                                                                     | verify | 
[INFO] [stderr]                                                                        < take_while | +1
[INFO] [stderr]                                                                                 > repeat_fold | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                    > Label("record field") | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                     >  | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                      > not | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                       > alt | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        > "let" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                        > "if" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "if" | backtrack
[INFO] [stderr]                                                                                                        > "else" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "else" | backtrack
[INFO] [stderr]                                                                                                        > "while" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "while" | backtrack
[INFO] [stderr]                                                                                                        > "return" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "return" | backtrack
[INFO] [stderr]                                                                                                        > "break" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                        > "continue" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                        > "fun" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                        > "true" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                        > "false" | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                       < alt | backtrack
[INFO] [stderr]                                                                                                      < not | +0
[INFO] [stderr]                                                                                                      > Label("variable") | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                       > alpha1 | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        > take_while | "x = 3, y = false, z = 5}
[INFO] [stderr]                                                                                                        < take_while | +1
[INFO] [stderr]                                                                                                       < alpha1 | +1
[INFO] [stderr]                                                                                                       > take_while | " = 3, y = false, z = 5};
[INFO] [stderr]                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                      < Label("variable") | +1
[INFO] [stderr]                                                                                                      > space0 | " = 3, y = false, z = 5};
[INFO] [stderr]                                                                                                       > take_while | " = 3, y = false, z = 5};
[INFO] [stderr]                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                      < space0 | +1
[INFO] [stderr]                                                                                                      > "=" | "= 3, y = false, z = 5};\
[INFO] [stderr]                                                                                                      < "=" | +1
[INFO] [stderr]                                                                                                      > space0 | " 3, y = false, z = 5};\n
[INFO] [stderr]                                                                                                       > take_while | " 3, y = false, z = 5};\n
[INFO] [stderr]                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                      < space0 | +1
[INFO] [stderr]                                                                                                      > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                       > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                        > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                       > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                        > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                         > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                          > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                         > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                          > Self :: Add | "3, y = false, z = 5};\nl
[INFO] [stderr]                          > delimited                | "y + r.a"∅
[INFO] [stderr]                                                                                                            > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                             > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                            > preceded | "y + r.a"∅
[INFO] [stderr]                                                                                                             > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                              > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                             > alt | "y + r.a"∅
[INFO] [stderr]                                                                                                              > preceded | "y + r.a"∅
[INFO] [stderr]                                                                                                               > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                                > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                               > alt | "y + r.a"∅
[INFO] [stderr]                                                                                                                > Self :: Add | "y + r.a"∅
[INFO] [stderr]                                                                                                                 > preceded | "y + r.a"∅
[INFO] [stderr]                                                                                                                  > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                                   > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                  > alt | "y + r.a"∅
[INFO] [stderr]                                                                                                                   > Self :: Let | "y + r.a"∅
[INFO] [stderr]                                                                                                                    > "let" | "y + r.a"∅
[INFO] [stderr]                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                   > Self :: Func | "y + r.a"∅
[INFO] [stderr]                                                                                                                    > "fun" | "y + r.a"∅
[INFO] [stderr]                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                   > Label("record") | "y + r.a"∅
[INFO] [stderr]                                                                                                                    > delimited | "y + r.a"∅
[INFO] [stderr]                                                                                                                     > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                                      > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                     > '{' | "y + r.a"∅
[INFO] [stderr]                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                   > Self :: With | "y + r.a"∅
[INFO] [stderr]                                                                                                                    > "with" | "y + r.a"∅
[INFO] [stderr]                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                   > preceded | "y + r.a"∅
[INFO] [stderr]                                                                                                                    > multispace0 | "y + r.a"∅
[INFO] [stderr]                                                                                                                     > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                    > alt | "y + r.a"∅
[INFO] [stderr]                                                                                                                     > not | "y + r.a"∅
[INFO] [stderr]                                                                                                                      > alt | "y + r.a"∅
[INFO] [stderr]                                                                                                                       > "let" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                       > "if" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                       > "else" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                       > "while" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                       > "return" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                       > "break" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                       > "continue" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                       > "fun" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                       > "true" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                       > "false" | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                     > Label("variable") | "y + r.a"∅
[INFO] [stderr]                                                                                                                      > alpha1 | "y + r.a"∅
[INFO] [stderr]                                                                                                                       > take_while | "y + r.a"∅
[INFO] [stderr]                                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                                      < alpha1 | +1
[INFO] [stderr]                                                                                                                      > take_while | " + r.a"∅
[INFO] [stderr]                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                     < Label("variable") | +1
[INFO] [stderr]                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                   < multispace0 | +0
[INFO] [stderr]       > delimited                                   | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                   > multispace0 | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                    > take_while | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                   > preceded | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                    > multispace0 | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                     > take_while | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                    > alt | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                     > preceded | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                      > multispace0 | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                       > take_while | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                      > alt | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                       > Self :: Add | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                        > preceded | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                         > multispace0 | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                          > take_while | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                         > alt | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                          > Self :: Let | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                           > "let" | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                           < "let" | +3
[INFO] [stderr]                                                                                                                           > space1 | " x = 1; x"∅
[INFO] [stderr]                                                                                                                            > take_while | " x = 1; x"∅
[INFO] [stderr]                                                                                                                            < take_while | +1
[INFO] [stderr]                                                                                                                           < space1 | +1
[INFO] [stderr]                                                                                                                           > not | "x = 1; x"∅
[INFO] [stderr]                                                                                                                            > alt | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             > "let" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                             > "if" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                             > "else" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "else" | backtrack
[INFO] [stderr]                                                                                                                             > "while" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "while" | backtrack
[INFO] [stderr]                                                                                                                             > "return" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                             > "break" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                             > "continue" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                             > "fun" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                             > "true" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                            > "false" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                       < take_while | +1
[INFO] [stderr]                                                                      < multispace0 | +1
[INFO] [stderr]                                                                                                                           > "+" | "+ 2"∅
[INFO] [stderr]                                                                                                                           < "+" | +1
[INFO] [stderr]                                                                                                                           > multispace0 | " 2"∅
[INFO] [stderr]                                                                                                                            > take_while | " 2"∅
[INFO] [stderr]                                                                                                                            < take_while | +1
[INFO] [stderr]                                                                                                                           < multispace0 | +1
[INFO] [stderr]                                                                                                                           > preceded | "2"∅
[INFO] [stderr]                                                                                                                            > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                             > take_while | "2"∅
[INFO] [stderr]                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                            > alt | "2"∅
[INFO] [stderr]                                                                                                                             > preceded | "2"∅
[INFO] [stderr]                                                                                                                              > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                               > take_while | "2"∅
[INFO] [stderr]                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                              > alt | "2"∅
[INFO] [stderr]                                                                                                                               > Self :: Add | "2"∅
[INFO] [stderr]                                                                                                                                > preceded | "2"∅
[INFO] [stderr]                                                                                                                                 > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                  > take_while | "2"∅
[INFO] [stderr]                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                 > alt | "2"∅
[INFO] [stderr]                                                                                                                                  > Self :: Let | "2"∅
[INFO] [stderr]                                                                                                                                   > "let" | "2"∅
[INFO] [stderr]                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                  > Self :: Func | "2"∅
[INFO] [stderr]                                                                                                                                   > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                  > Label("record") | "2"∅
[INFO] [stderr]                                                                                                                                   > delimited | "2"∅
[INFO] [stderr]                                                                                                                                    > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                     > take_while | "2"∅
[INFO] [stderr]                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                    > '{' | "2"∅
[INFO] [stderr]                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                  > Self :: With | "2"∅
[INFO] [stderr]                                                                                                                                   > "with" | "2"∅
[INFO] [stderr]                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                  > preceded | "2"∅
[INFO] [stderr]        > delimited                                  | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                       > Self :: With | "true"∅
[INFO] [stderr]                                                > take_while | "(1)"∅
[INFO] [stderr]                                                                                                                             > alt | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                                                    > Self :: Let | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                                                     > "let" | "let f = fun(x: num) { le
[INFO] [stderr]                                                                                                                                     < "let" | +3
[INFO] [stderr]                                                                                                                                     > space1 | " f = fun(x: num) { let z
[INFO] [stderr]                                                                                                                                      > take_while | " f = fun(x: num) { let z
[INFO] [stderr]                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                                                                                                     < space1 | +1
[INFO] [stderr]                                                                                                                                     > not | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                      > alt | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       > "let" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                       > "if" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                       > "else" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                       > "while" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                       > "return" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                       > "break" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                       > "continue" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                       > "fun" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                       > "true" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                       > "false" | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                                     > Label("variable") | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                      > alpha1 | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       > take_while | "f = fun(x: num) { let z 
[INFO] [stderr]                                                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                                                      < alpha1 | +1
[INFO] [stderr]                                                                                                                                      > take_while | " = fun(x: num) { let z =
[INFO] [stderr]                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                     < Label("variable") | +1
[INFO] [stderr]                                                                                                                                     > space0 | " = fun(x: num) { let z =
[INFO] [stderr]                                                                                                                                      > take_while | " = fun(x: num) { let z =
[INFO] [stderr]                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                < take_while | +0
[INFO] [stderr]                                               < Label("variable") | +3
[INFO] [stderr]                                               < alt | +3
[INFO] [stderr]                                              < preceded | +3
[INFO] [stderr]                                             < alt   | +3
[INFO] [stderr]                                            < preceded | +3
[INFO] [stderr]                                                                                                                                > multispace0 | "(1)"∅
[INFO] [stderr]                                                                                                                                 > take_while | "(1)"∅
[INFO] [stderr]                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                > "+" | "(1)"∅
[INFO] [stderr]                                                                                                                                < "+" | backtrack
[INFO] [stderr]                                           < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                               > Label("record access") | "add(1)"∅
[INFO] [stderr]                                                                                                                                > Self :: RecordAccess | "add(1)"∅
[INFO] [stderr]                                                                                                                                 > preceded | "add(1)"∅
[INFO] [stderr]                                                                                                                                  > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                   > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                  > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                   > Self :: Let | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "let" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                   > Self :: Func | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "fun" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                   > Label("record") | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > delimited | "add(1)"∅
[INFO] [stderr]                                                                                                                                     > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                      > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                     > '{' | "add(1)"∅
[INFO] [stderr]                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                   > Self :: With | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "with" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                    > preceded | "add(1)"∅
[INFO] [stderr]                                                                                                                                     > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                      > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                     > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                      > not | "add(1)"∅
[INFO] [stderr]                                                                                                                                       > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                        > "let" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                        > "if" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "if" | backtrack
[INFO] [stderr]                                                                                                                                        > "else" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "else" | backtrack
[INFO] [stderr]                                                                                                                                        > "while" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "while" | backtrack
[INFO] [stderr]                                                                                                                                        > "return" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "return" | backtrack
[INFO] [stderr]                                                                                                                                        > "break" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                                                        > "continue" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                                                        > "fun" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                        > "true" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                        > "false" | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                       < alt | backtrack
[INFO] [stderr]                                                                                                                                      < not | +0
[INFO] [stderr]                                                                                                                                      > Label("variable") | "add(1)"∅
[INFO] [stderr]                                                                                                                                       > alpha1 | "add(1)"∅
[INFO] [stderr]                                                                                                                                        > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                        < take_while | +3
[INFO] [stderr]                                                                                                                                       < alpha1 | +3
[INFO] [stderr]                                                                                                                                       > take_while | "(1)"∅
[INFO] [stderr]                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                      < Label("variable") | +3
[INFO] [stderr]                                                                                                                                     < alt | +3
[INFO] [stderr]                                                                                                                                    < preceded | +3
[INFO] [stderr]                                                                                                                                  < alt | +3
[INFO] [stderr]                                                                                                                                 < preceded | +3
[INFO] [stderr]                                                                                                                                  > '.' | "(1)"∅
[INFO] [stderr]                                                                                                                                  < '.' | backtrack
[INFO] [stderr]                                                                                                                                < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                               < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                > Self :: Call | "add(1)"∅
[INFO] [stderr]                                                                                                                                 > preceded | "add(1)"∅
[INFO] [stderr]                                                                                                                                  > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                   > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                  > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                   > Self :: Let | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "let" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                   > Self :: Func | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "fun" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                   > Label("record") | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > delimited | "add(1)"∅
[INFO] [stderr]                                                                                                                                     > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                      > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                     > '{' | "add(1)"∅
[INFO] [stderr]                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                   > Self :: With | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > "with" | "add(1)"∅
[INFO] [stderr]                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                   > preceded | "add(1)"∅
[INFO] [stderr]                                                                                                                                    > multispace0 | "add(1)"∅
[INFO] [stderr]                                                                                                                                     > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                           > delimited               | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                     > multispace0 | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                      > take_while | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                     > preceded | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                      > multispace0 | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                       > take_while | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                      > alt | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                       > preceded | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                        > multispace0 | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                         > take_while | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                        > alt | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                         > Self :: Add | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                          > preceded | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                           > multispace0 | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                   > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                             > take_while | "2"∅
[INFO] [stderr]                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                            > alt | "2"∅
[INFO] [stderr]                                                                                                                                             > not | "2"∅
[INFO] [stderr]                                                                                                                                              > alt | "2"∅
[INFO] [stderr]                                                                                                                                               > "let" | "2"∅
[INFO] [stderr]                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                               > "if" | "2"∅
[INFO] [stderr]                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                               > "else" | "2"∅
[INFO] [stderr]                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                               > "while" | "2"∅
[INFO] [stderr]                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                               > "return" | "2"∅
[INFO] [stderr]                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                               > "break" | "2"∅
[INFO] [stderr]                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                               > "continue" | "2"∅
[INFO] [stderr]                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                               > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                               > "true" | "2"∅
[INFO] [stderr]                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                               > "false" | "2"∅
[INFO] [stderr]                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                                             < not | +0
[INFO] [stderr]                                                                                                                                             > Label("variable") | "2"∅
[INFO] [stderr]                                                                                                                                              > alpha1 | "2"∅
[INFO] [stderr]                                                                                                                                               > take_while | "2"∅
[INFO] [stderr]                                                                                                                                               < take_while | backtrack
[INFO] [stderr]                                                                                                                                              < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                             < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                             > Expected(Description("number")) | "2"∅
[INFO] [stderr]                                                                                                                                              > Label("literal") | "2"∅
[INFO] [stderr]                                                                                                                                               > digit1 | "2"∅
[INFO] [stderr]                                                                                                                                                > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                < take_while | +1
[INFO] [stderr]                                                                                                                                    > "with" | "true"∅
[INFO] [stderr]                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                       < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                               > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                 > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                > alt | "true"∅
[INFO] [stderr]                                                                                                                                                 > not | "true"∅
[INFO] [stderr]                                                                                                                                                  > alt | "true"∅
[INFO] [stderr]                                                                                                                                                   > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                   > "if" | "true"∅
[INFO] [stderr]                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                   > "else" | "true"∅
[INFO] [stderr]                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                            > take_while | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                 > alt | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                  > Self :: Let | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   > "let" | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                  > Self :: Func | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   > "fun" | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                  > Label("record") | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   > delimited | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                    > multispace0 | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                     > take_while | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                    > '{' | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                  > Self :: With | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   > "with" | "with {x = 3, y = 2} do {
[INFO] [stderr]                                                                                                                                                   < "with" | +4
[INFO] [stderr]                                                                                                                                                   > space1 | " {x = 3, y = 2} do {x + 
[INFO] [stderr]                                                                                                                                                    > take_while | " {x = 3, y = 2} do {x + 
[INFO] [stderr]                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                   < space1 | +1
[INFO] [stderr]                                                                                                                                                   > preceded | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                    > multispace0 | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                     > take_while | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                    > alt | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                     > preceded | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                            > "break" | "x"∅
[INFO] [stderr]                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                     > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                     > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                     > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                     > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                               < digit1 | +1
[INFO] [stderr]                                                                                                                                  > multispace0 | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                            > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                                     > not | "add(1)"∅
[INFO] [stderr]                                                                                                                                                      > alt | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       > "let" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                       > "if" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                                       > "else" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                       > "while" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                       > "return" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                       > "break" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                                       > "continue" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                       > "fun" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                       > "true" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                                       > "false" | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                                                     > Label("variable") | "add(1)"∅
[INFO] [stderr]                                                                                                                                                      > alpha1 | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       > take_while | "add(1)"∅
[INFO] [stderr]                                                                                                                                                       < take_while | +3
[INFO] [stderr]                                                                                                                                                      < alpha1 | +3
[INFO] [stderr]                                                                                                                                                      > take_while | "(1)"∅
[INFO] [stderr]                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                     < Label("variable") | +3
[INFO] [stderr]                                                                                                                                            < alt | +3
[INFO] [stderr]                                                                                                                                   < preceded | +3
[INFO] [stderr]                                                                                                                                  < alt | +3
[INFO] [stderr]                                                                                                                                 < preceded | +3
[INFO] [stderr]                                                                                                                                                 > space0 | "(1)"∅
[INFO] [stderr]                                                                                                                                                   > take_while | "(1)"∅
[INFO] [stderr]                                                                                                           > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                    > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                     > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                    > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                     > Self :: Let | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                     > Self :: Func | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                     > Label("record") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      > delimited | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                       > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                        > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                       > '{' | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                       < '{' | backtrack
[INFO] [stderr]                                                                                                                                                      < delimited | backtrack
[INFO] [stderr]                                                                                                                                                     < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                     > Self :: With | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      > "with" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                     < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                     > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                      > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                       > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                      > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                       > not | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                        > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                         > "if" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                         > "else" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                         > "while" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                         > "return" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                         > "break" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                         > "continue" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                         > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                         > "true" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                            < alt | backtrack
[INFO] [stderr]                                                                                           < not | +0
[INFO] [stderr]                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                        > multispace0 | " + r.a"∅
[INFO] [stderr]                                                                                                                                                         > take_while | " + r.a"∅
[INFO] [stderr]                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                        < multispace0 | +1
[INFO] [stderr]                                                                                                                                                        > "+" | "+ r.a"∅
[INFO] [stderr]                                                                                                                                                        < "+" | +1
[INFO] [stderr]                                                                                                                                                        > multispace0 | " r.a"∅
[INFO] [stderr]                                                                                                                                                         > take_while | " r.a"∅
[INFO] [stderr]                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                        < multispace0 | +1
[INFO] [stderr]                                                                                                                                                        > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                         > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                          > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                         > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                          > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                           > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                            > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                           > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                            > Self :: Add | "r.a"∅
[INFO] [stderr]                                                                                                                                                             > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                              > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                               > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                              > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                               > Self :: Let | "r.a"∅
[INFO] [stderr]                                                                                                                                                                > "let" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                               > Self :: Func | "r.a"∅
[INFO] [stderr]                                                                                                                                                                > "fun" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                               > Label("record") | "r.a"∅
[INFO] [stderr]                                                                                                                                                                > delimited | "r.a"∅
[INFO] [stderr]                                                                                                                                                                 > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                  > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                 > '{' | "r.a"∅
[INFO] [stderr]                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                               > Self :: With | "r.a"∅
[INFO] [stderr]                                                                                                                                                                > "with" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                               > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                                > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                 > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                                 > not | "r.a"∅
[INFO] [stderr]                                                                                                                                                                  > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   > "let" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "if" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "else" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "while" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "return" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "break" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "continue" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "fun" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "true" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                   > "false" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                 < not | +0
[INFO] [stderr]                                                                                                                                                                 > Label("variable") | "r.a"∅
[INFO] [stderr]                                                                                                                                                                  > alpha1 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                  < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                  > take_while | ".a"∅
[INFO] [stderr]                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                 < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                             > multispace0 | ".a"∅
[INFO] [stderr]                                                                                                                                                              > take_while | ".a"∅
[INFO] [stderr]                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                             > "+" | ".a"∅
[INFO] [stderr]                                                                                                                                                             < "+" | backtrack
[INFO] [stderr]                                                                                                                                                            < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                            > Label("record access") | "r.a"∅
[INFO] [stderr]                                                                       < alpha1 | +1
[INFO] [stderr]                                                                                                                                                             > take_while | " = fun(x: number) { x + 
[INFO] [stderr]                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                      < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                            > space0 | " = fun(x: number) { x + 
[INFO] [stderr]                                                                                                                                                             > take_while | " = fun(x: number) { x + 
[INFO] [stderr]                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                            > '=' | "= fun(x: number) { x + 1
[INFO] [stderr]                                                                                                                                                            < '=' | +1
[INFO] [stderr]                                                                                                                                                            > space0 | " fun(x: number) { x + 1 
[INFO] [stderr]                                                                                                                                                             > take_while | " fun(x: number) { x + 1 
[INFO] [stderr]                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                            > cut_err | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                             > Expected(Description("expression")) | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                              > Label("body expression") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                               > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                 > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                 > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                  > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                   > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                  > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                   > Self :: Add | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                    > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                     > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                      > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                      > Self :: Let | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                       > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                      > Self :: Func | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                       > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                       < "fun" | +3
[INFO] [stderr]                                                                                                                                                                       > space0 | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                        > take_while | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                       > '(' | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                       < '(' | +1
[INFO] [stderr]                                                                                                                                                                       > space0 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                        > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                       > not | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                        > alt | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         > "let" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "if" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "else" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "while" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "return" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "break" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "continue" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "fun" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "true" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                         > "false" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                       > Label("variable") | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                        > alpha1 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                        < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                        > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                       > space0 | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                        > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                       > ':' | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                       < ':' | +1
[INFO] [stderr]                                                                                                                                                                       > space0 | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                        > take_while | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                        < take_while | +1
[INFO] [stderr]                                                                                                                                                                       < space0 | +1
[INFO] [stderr]                                                                                                                                                                       > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                        > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                         > delimited | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                          > "{" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                          < "{" | backtrack
[INFO] [stderr]                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                         >  | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                          > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                           > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                           < "num" | +3
[INFO] [stderr]                                                                                                                                                                          < alt | +3
[INFO] [stderr]                                                                                                                                                                          > "->" | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                          < "->" | backtrack
[INFO] [stderr]                                                                                                                                                                         <  | backtrack
[INFO] [stderr]                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                        > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                         > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                         < "num" | +3
[INFO] [stderr]                                                                                                                                                                        < alt | +3
[INFO] [stderr]                                                                                                                                                                       < alt | +3
[INFO] [stderr]                                                                                                                                                                       > space0 | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                        > take_while | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                       > ')' | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                    > "while" | "true"∅
[INFO] [stderr]                                                                                                                                                  > take_while | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                             > Self :: RecordAccess | "r.a"∅
[INFO] [stderr]                                                                                                                                     < space0 | +1
[INFO] [stderr]                                                                                                                                                                       > '=' | "= fun(x: num) { let z = 
[INFO] [stderr]                                                                                                                                                                       < '=' | +1
[INFO] [stderr]                                                                                                                                                                       > space0 | " fun(x: num) { let z = x
[INFO] [stderr]                                                                                                                                                                        > take_while | " fun(x: num) { let z = x
[INFO] [stderr]                                                                                                                                                                        < take_while | +1
[INFO] [stderr]                                                                                                                                                                       < space0 | +1
[INFO] [stderr]                                                                                                                                                                       > cut_err | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                        > Expected(Description("expression")) | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                         > Label("body expression") | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                          > preceded | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                           > multispace0 | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                            > take_while | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                           > alt | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                            > preceded | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                              > take_while | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > alt | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                              > Self :: Add | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                               > preceded | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                 > take_while | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > alt | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                 > Self :: Let | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                  > "let" | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Self :: Func | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                  > "fun" | "fun(x: num) { let z = x;
[INFO] [stderr]                                                                                                                                                                                  < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                   > space0 | "(x: num) { let z = x; tr
[INFO] [stderr]                                                                                                                                                                                    > take_while | "(x: num) { let z = x; tr
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                   > '(' | "(x: num) { let z = x; tr
[INFO] [stderr]                                                                                                                                                                                   < '(' | +1
[INFO] [stderr]                                                                                                                                                                                   > space0 | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                    > take_while | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                   > not | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                    > alt | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                     > "let" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "if" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "else" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "return" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "break" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "continue" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "true" | +4
[INFO] [stderr]                                                                                                                                                  < alt | +4
[INFO] [stderr]                                                                                                                                                 < not | backtrack
[INFO] [stderr]                                                                                                                                                                                   > Expected(Description("number")) | "true"∅
[INFO] [stderr]                                                                                                                                                                                    > Label("literal") | "true"∅
[INFO] [stderr]                                                                                                                                                                                     > digit1 | "true"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                     < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                   > Label("boolean") | "true"∅
[INFO] [stderr]                                                                                                                                                                                    > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                     > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                     < "true" | +4
[INFO] [stderr]                                                                                                                                                                                    < alt | +4
[INFO] [stderr]                                                                                                                                                                                   < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                < alt | +4
[INFO] [stderr]                                                                                                                                               < preceded | +4
[INFO] [stderr]                                    < alt            | +4
[INFO] [stderr]                                   < preceded        | +4
[INFO] [stderr]                                                                                                                                                                               > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                      > multispace0 | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "false" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                < "false" | backtrack
[INFO] [stderr]                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                              > Label("variable") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               > alpha1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                               < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                              < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                              > Expected(Description("number")) | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               > Label("literal") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                > digit1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                | verify | 
[INFO] [stderr]                                                                                                                                                                               < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                              < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                      < alt | +1
[INFO] [stderr]                                                                                                                                                     < preceded | +1
[INFO] [stderr]                                                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                          > multispace0 | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                           > take_while | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                          > "+" | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                          < "+" | backtrack
[INFO] [stderr]                                                                                                          < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                         > Label("record access") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                          > Self :: RecordAccess | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                           > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                            > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                             > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                            > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                             > Self :: Let | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                             < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                             > Self :: Func | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                             < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                             > Label("record") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              > delimited | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > '{' | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                             < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                             > Self :: With | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              > "with" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                             < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                             > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                              > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                               > not | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "if" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "else" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "while" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "return" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "break" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "continue" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                 > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                       < ')' | backtrack
[INFO] [stderr]                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > preceded | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > alt | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 > preceded | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > alt | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   > Self :: Add | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    > preceded | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                     > multispace0 | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                     > alt | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                      > Self :: Let | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       > "let" | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                      > Self :: Func | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       > "fun" | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                      > Label("record") | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       > delimited | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                        > multispace0 | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > take_while | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                        > '{' | "{x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                        < '{' | +1
[INFO] [stderr]                                                                                                                                                                                        > multispace0 | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > take_while | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                        > repeat_fold | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                          > Self :: Let | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           > "let" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Self :: Func | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           > "fun" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Label("record") | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           > delimited | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > '{' | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                            < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Self :: With | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           > "with" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                          > preceded | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                           > multispace0 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                           > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                            > not | "r.a"∅
[INFO] [stderr]                                                                                                                                                     | verify | 
[INFO] [stderr]                                                                                                                                              < Label("literal") | +1
[INFO] [stderr]                                                                                                                                             < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                  < preceded | +1
[INFO] [stderr]                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                       < "+" | backtrack
[INFO] [stderr]                                                                                                                               < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                      > Label("record access") | "2"∅
[INFO] [stderr]                                                                                                                                                                                       > Self :: RecordAccess | "2"∅
[INFO] [stderr]                                                                                                                                                                                        > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                          > Self :: Let | "2"∅
[INFO] [stderr]                                                                                                                                                                                           > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                     < Label("literal") | +10
[INFO] [stderr]                                                                                                                                                                                 > "true" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                            < alt | backtrack
[INFO] [stderr]                                                                                                                           < not | +0
[INFO] [stderr]                                                                                                                                                                                         > Label("variable") | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          > alpha1 | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                           > take_while | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                          < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                          > take_while | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                         > space0 | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +1
[INFO] [stderr]                                                                                                                                                                                         < space0 | +1
[INFO] [stderr]                                                                                                                                                                                         > '=' | "= 1; x"∅
[INFO] [stderr]                                                                                                                                                                                         < '=' | +1
[INFO] [stderr]                                                                                                                                                                                         > space0 | " 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | " 1; x"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +1
[INFO] [stderr]                                                                                                                                                                                         < space0 | +1
[INFO] [stderr]                                                                                                                                                                                         > cut_err | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                          > Expected(Description("expression")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                           > Label("body expression") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                            > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                              > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                > Self :: Add | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                     > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                     > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                     > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                      > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                 < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                       > '(' | "(1)"∅
[INFO] [stderr]                                                                                                                                                                                                       < '(' | +1
[INFO] [stderr]                                                                                                                                                                                                       > space0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                        > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                       > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                        > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                         > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                        > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                         > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                          > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                           > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                          > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                           > Self :: Add | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                            > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                             > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                              > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                             > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                              > Self :: Let | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                               > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                              > Self :: Func | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                               > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                               > Self :: Func | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                               > Label("record") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                > delimited | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                 > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                 > '{' | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                               > Self :: With | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                > "with" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                               > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                 > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                 > not | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  > "if" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                               < "+" | backtrack
[INFO] [stderr]                                  < Self :: Add      | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Label("record access") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                  > Self :: RecordAccess | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                   > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                    > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                     > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                    > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: Let | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: Func | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > Label("record") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      > delimited | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                       > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > '{' | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                       < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: With | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                      > "with" | "true"∅
[INFO] [stderr]                                                                                                                                                                                         > Label("record field") | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > "while" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "return" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "break" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "continue" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "fun" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "true" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "false" | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                                                                                     > Label("variable") | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                      > alpha1 | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       > take_while | "x: num) { let z = x; tru
[INFO] [stderr]                                                                                                                                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                      < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | ": num) { let z = x; true
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                     > space0 | ": num) { let z = x; true
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | ": num) { let z = x; true
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > ':' | ": num) { let z = x; true
[INFO] [stderr]                                                                                                                                                                                                                     < ':' | +1
[INFO] [stderr]                                                                                                                                                                                                                     > space0 | " num) { let z = x; true 
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | " num) { let z = x; true 
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                     < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                     > alt | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                      > alt | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                       > delimited | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                        > "{" | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                        < "{" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       >  | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                        > alt | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                         > "num" | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                         < "num" | +3
[INFO] [stderr]                                                                                                                                                        > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                          < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                          > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                        < Label("variable") | +1
[INFO] [stderr]                                                                                          < alt | +1
[INFO] [stderr]                                                                                         < preceded | +1
[INFO] [stderr]                                                                                        < alt | +1
[INFO] [stderr]                                                                                       < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                     > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                                                     < "+" | backtrack
[INFO] [stderr]                                                                                      < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > Label("record access") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: RecordAccess | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                         > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "false" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                       >  | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > not | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              > "let" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "if" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "else" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "while" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "return" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "break" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "continue" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "fun" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "true" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "false" | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                                            > Label("variable") | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > alpha1 | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "x = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                             < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | " = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                            < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                            > space0 | " = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | " = 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                            > "=" | "= 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "=" | +1
[INFO] [stderr]                                                                                                                                                                                > take_while | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                               > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                                                                                                                          > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                            < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                            | verify | 
[INFO] [stderr]                                                                                                                                                                                                                           < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                          < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                      > multispace0 | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > take_while | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                      > "+" | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                      < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > Label("record access") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: RecordAccess | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > alt | "1; x"∅
[INFO] [stderr]                                                                                                    < Expected(Description("number")) | +10
[INFO] [stderr]                                                                                                   < alt | +10
[INFO] [stderr]                                                                                                  < preceded | +10
[INFO] [stderr]                        < alt                        | +10
[INFO] [stderr]                       < preceded                    | +10
[INFO] [stderr]                                                                                                                                                                                                                        > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                                                        < "+" | backtrack
[INFO] [stderr]                      < Self :: Add                  | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < not | +0
[INFO] [stderr]                                                                                                                                                                                                                      > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                       < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                       > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                      < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                      < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                  > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                  < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > Self :: Call | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                 > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                  > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                   > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                    > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > "else" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "while" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "return" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "break" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "continue" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "true" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > "false" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < not | +0
[INFO] [stderr]                                                                                                                                                                                                                 > Label("variable") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  > alpha1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Expected(Description("number")) | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                  > Label("literal") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                   > digit1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                   < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                   | verify | 
[INFO] [stderr]                                                                                                                                                                                                                  < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                 < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                             > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                                             < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                      < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                          > Self :: Call | "2"∅
[INFO] [stderr]                                                                                                                                                                                                           > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                                            > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                             > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                            > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                             > Self :: Let | "2"∅
[INFO] [stderr]                                                                                                                                                                                                              > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                                             > Label("variable") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                              > alpha1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                               > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                               < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > Expected(Description("number")) | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                              > Label("literal") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                               > digit1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                               < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                               | verify | 
[INFO] [stderr]                                                                                                                                                                                                              < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                             < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                        > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < alt | +3
[INFO] [stderr]                                                                                                                                                                                                            > "->" | ") { let z = x; true }; f
[INFO] [stderr]                                                                                                                                                                                                            < "->" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       <  | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > space0 | " 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                           > take_while | " 3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                          > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                           > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                            > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                           > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                            > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                             > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                              > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                             > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                              > Self :: Add | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                               > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                 > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: Let | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                  > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: Func | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                  > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Label("record") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                  > delimited | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                   > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                > '.' | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                                < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                          < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                         < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                              > Self :: Call | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                               > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                 > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: Let | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: Func | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Label("record") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  > delimited | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                   > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                   > '{' | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: With | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  > "with" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > Label("record access") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                   > Self :: RecordAccess | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                     > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Let | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Func | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Label("record") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       > delimited | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                        > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > '{' | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                        < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: With | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "with" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                       > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                        > not | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Label("record") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         > delimited | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Self :: Func | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Label("record") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > delimited | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                            > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                            > '{' | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                            < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Self :: With | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > "with" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Label("record") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            > delimited | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > '{' | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                             < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: With | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            > "with" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              > not | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                               > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > "if" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > not | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "if" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                        > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                   < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                   | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                  < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                 < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                        < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                         > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "if" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "else" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "while" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "return" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "break" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "continue" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "true" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: Add | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                   > '{' | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > not | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                              > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "if" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "else" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "while" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "return" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "break" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "continue" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "true" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "false" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < not | +0
[INFO] [stderr]                                                                                                                                                                                                                             > Label("variable") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                              > alpha1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "else" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "while" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "return" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "break" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                   > alt | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                                > "num" | "num) { let z = x; true }
[INFO] [stderr]                                                                                                                                                                                                                                < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                                  > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "else" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "while" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "return" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "break" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "continue" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                               > '.' | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                  > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "continue" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                                               < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                              < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > Expected(Description("number")) | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                   > Label("literal") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    > digit1 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                     > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > Label("boolean") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    > "true" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "false" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < Label("boolean") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > Label("atom") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                   > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                   < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < Label("atom") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > Label("term") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                 > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                 < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Label("term") | backtrack
[INFO] [stderr]                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                    < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                   < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > Label("record access") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: RecordAccess | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                               > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                 > Self :: Let | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                  > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > Self :: Func | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                  > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                  < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                                                  > space0 | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                  > '(' | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                                  < '(' | +1
[INFO] [stderr]                                                                                                                                                                                                                                  > space0 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                  > not | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    > "let" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "if" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "else" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "while" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "return" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "break" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                   < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                     < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                                   > space0 | ") { let z = x; true }; f
[INFO] [stderr]                                                                                                                                                                                                                                    > take_while | ") { let z = x; true }; f
[INFO] [stderr]                                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                   > ')' | ") { let z = x; true }; f
[INFO] [stderr]                                                                                                                                                                                                                                   < ')' | +1
[INFO] [stderr]                                                                                                                                                                                                                                   > delimited | " { let z = x; true }; f(
[INFO] [stderr]                                                                                                                                                                                                                                    > multispace0 | " { let z = x; true }; f(
[INFO] [stderr]                                                                                                                                                                                                                                     > take_while | " { let z = x; true }; f(
[INFO] [stderr]                                                                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                    < multispace0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                    > '{' | "{ let z = x; true }; f(1
[INFO] [stderr]                                                                                                                                                                                                                                    < '{' | +1
[INFO] [stderr]                                                                                                                                                                                                                                    > multispace0 | " let z = x; true }; f(1)
[INFO] [stderr]                                                                                                                                                                                                                                     > take_while | " let z = x; true }; f(1)
[INFO] [stderr]                                                                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                    < multispace0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                    > preceded | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                     > multispace0 | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                      > take_while | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                               > '{' | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > Self :: With | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > "with" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                     < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                     > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > not | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "if" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "else" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "while" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "return" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "break" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "continue" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "true" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > "false" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                      > Label("variable") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > alpha1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > Expected(Description("number")) | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > Label("literal") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > digit1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                        < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                        | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                       < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                      < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                     < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                    < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                  > multispace0 | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | ")"∅
[INFO] [stderr]                                                                                                                                                                                           > alt | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                               > preceded | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                    > multispace0 | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                     > take_while | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                    > alt | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                     > Self :: Let | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                      > "let" | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     > Self :: Func | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                      > "fun" | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     > Label("record") | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                      > delimited | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                       > multispace0 | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                       > '{' | "{x = 3, y = 2} do {x + y
[INFO] [stderr]                                                                                                                                                                                                                                       < '{' | +1
[INFO] [stderr]                                                                                                                                                                                                                                       > multispace0 | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                              > "false" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: With | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > "with" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > not | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                             > not | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                              > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "if" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "else" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "while" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "return" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "break" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "continue" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "true" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "false" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                             > Label("variable") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                              > alpha1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                               < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > Expected(Description("number")) | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                              > Label("literal") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                              > digit1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                               > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                               < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            > Expected(Description("number")) | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > Label("literal") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > digit1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                              < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                              | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                             < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                        > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                         > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                        < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                        > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                        < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                          < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       > Label("extension") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Extension | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                  < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       > Expected(Description("number")) | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > Label("literal") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > digit1 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                         > alt | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                          > preceded | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                           > multispace0 | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                            > take_while | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > alt | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Call | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "let" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "if" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "else" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "while" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "return" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "break" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "continue" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "fun" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "true" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "false" | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                           < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > Label("variable") | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alpha1 | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("record") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > delimited | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > Label("variable") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > alpha1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            > Expected(Description("number")) | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > Label("literal") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                              < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                           | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                              < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                             < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                         > "continue" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "fun" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                     > space0 | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                     > "+" | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                                     < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > Label("record access") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > Self :: RecordAccess | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                       > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Let | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Func | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > Label("record") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > delimited | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > '{' | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: With | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > "with" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                             > repeat_fold | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              > Label("record field") | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                               >  | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                                > not | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                                 > alt | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                                  > "let" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                  > "if" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                  > "else" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                                  > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > Self :: Add | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                     > preceded | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                      > multispace0 | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                       > take_while | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                      > alt | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                       > Self :: Let | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                        > "let" | "let z = x; true }; f(1)"
[INFO] [stderr]                                                                                                                                                                                                                                                        < "let" | +3
[INFO] [stderr]                                                                                                                                                                                                                                                        > space1 | " z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                         > take_while | " z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                                        < space1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                                        > not | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                         > alt | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          > "let" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "if" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "else" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "while" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "return" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "break" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "continue" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > "fun" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "if" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "r.a"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                                         > take_while | ".a"∅
[INFO] [stderr]                                                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                                    > '.' | ".a"∅
[INFO] [stderr]                                                                                                                                                                                                                                                    < '.' | +1
[INFO] [stderr]                                                                                                                                                                                                                                                    > not | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                   > '(' | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                                                                   < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                  > Label("extension") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                   > Self :: Extension | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                    > Label("record") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                     > delimited | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                      > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                       > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                      > '{' | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                      < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                    < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                   < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                  < Label("extension") | backtrack
[INFO] [stderr]                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                        < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                      > "true" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                 > "false" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                               > Label("variable") | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                                > alpha1 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                                 > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                                < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                                > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                               < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                                               > space0 | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                                                                > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                               < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                 > ':' | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                                                                 < ':' | +1
[INFO] [stderr]                                                                                                                                                                                                                                                 > space0 | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                                                                  > take_while | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                                 < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                                 > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                  > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                   > delimited | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                    > "{" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                    < "{" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                   >  | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                    > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                     > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                                                     < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                                                                    < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                                                    > "->" | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                                                                    < "->" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > digit1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                                     > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                                     < take_while | +10
[INFO] [stderr]                                                                                                                                                                                                                                      < digit1 | +10
[INFO] [stderr]                                                                                                                                                                                                                                                    | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                             < Label("literal") | +10
[INFO] [stderr]                                                                                                                                                                                                                                            < Expected(Description("number")) | +10
[INFO] [stderr]                                                                                                                                                                                                                       < alt | +10
[INFO] [stderr]                                                                                                                                                                                                                      < preceded | +10
[INFO] [stderr]                                                                                                                                                                                                                                                   > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                                > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                                < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                                   < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                               > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                  < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                          > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                          < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                          < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > Label("extension") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Extension | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                             > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                          > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > not | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "if" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "else" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "while" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "return" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "break" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "continue" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "true" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "false" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > Label("variable") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alpha1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           > Expected(Description("number")) | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > Label("literal") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > digit1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                > alt | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "while" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "return" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "break" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "continue" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "fun" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "true" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              > "false" | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > Label("variable") | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                             > alpha1 | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "x = 3, y = 2} do {x + y}
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                             < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | " = 3, y = 2} do {x + y}"
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                                            > space0 | " = 3, y = 2} do {x + y}"
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | " = 3, y = 2} do {x + y}"
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                            > "=" | "= 3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < "=" | +1
[INFO] [stderr]                                                                                                                                                                                                                                            > space0 | " 3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | " 3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                            > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "else" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "while" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "return" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "break" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "continue" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "true" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               > "false" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                             > Label("variable") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > alpha1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > Expected(Description("number")) | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > Label("literal") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > digit1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                                > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                                < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                               < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                               | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                              < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                             < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                         > multispace0 | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < alt | +10
[INFO] [stderr]                                                                                                                                                                                                                    < preceded | +10
[INFO] [stderr]                                                                                                                                                                                                                                         > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                         < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       > Self :: Call | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                         > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Let | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Func | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("record") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > delimited | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > '{' | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: With | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "with" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > not | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "if" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "else" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "while" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "return" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "break" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "continue" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "true" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             > "false" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > Label("variable") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alpha1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           > Expected(Description("number")) | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > Label("literal") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > digit1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | +10
[INFO] [stderr]                                                                                                                                                                                                                                             < digit1 | +10
[INFO] [stderr]                                                                                                                                                                                                                                             | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                                          > "true" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                          < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            > "false" | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                        < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("variable") | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > alpha1 | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > take_while | "z = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | " = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                                          > space0 | " = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | " = x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                          > '=' | "= x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < '=' | +1
[INFO] [stderr]                                                                                                                                                                                                                                          > space0 | " x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > take_while | " x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                                          > cut_err | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > Expected(Description("expression")) | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > Label("body expression") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                              > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                 > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                 > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                               > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                > Self :: Let | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                > Self :: Func | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                > Label("record") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 > delimited | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                  > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                   > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                                  > '{' | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                > Self :: With | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 > "with" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                             < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                               | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                            < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                      < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                         > '.' | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       > Self :: Call | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                         > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Let | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Func | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("record") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > delimited | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                            > '{' | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: With | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "with" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                                    > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                          > '{' | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                             < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                     > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > Self :: Let | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > Self :: Func | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > Label("record") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > delimited | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                        > '{' | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                       > "+" | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > Label("record access") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > Self :: RecordAccess | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                         > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Let | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Self :: Func | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          > Label("record") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > delimited | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           > Label("boolean") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                            > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                             > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                                                            < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                           < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                    < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                   < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                                       > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                       < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     > Self :: Call | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                       > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Let | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        > Self :: Func | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                               > "let" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "if" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "else" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "while" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "return" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "break" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "continue" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "fun" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "true" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         > "false" | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                       > Label("variable") | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                        > alpha1 | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         > take_while | "a"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                        < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                        > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                       < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                             < Self :: RecordAccess | +3
[INFO] [stderr]                                                                                                                                                            < Label("record access") | +3
[INFO] [stderr]                                                                                                                                                           < alt | +3
[INFO] [stderr]                                                                                                                                                          < preceded | +3
[INFO] [stderr]                                                                                                                                                         < alt | +3
[INFO] [stderr]                                                                                                                                                        < preceded | +3
[INFO] [stderr]                                                                                                                < Self :: Add | +7
[INFO] [stderr]                                                                                                               < alt | +7
[INFO] [stderr]                                                                                                              < preceded | +7
[INFO] [stderr]                                                                                                             < alt | +7
[INFO] [stderr]                                                                                                            < preceded | +7
[INFO] [stderr]                                                                                                                                                                                                                            > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                                   <  | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                            > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                                            < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                                           < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                                                 < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                          > space0 | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > ')' | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                                          < ')' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Label("record") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                          > delimited | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > '{' | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                           < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Self :: With | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                          > "with" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                          < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                           > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                           < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                                         > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                           < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                           | verify | 
[INFO] [stderr]                                                                                                                                                                                                                          < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                         < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                     > space0 | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > '(' | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                     < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > Label("extension") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: Extension | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                         < Label("extension") | backtrack
[INFO] [stderr]                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                    < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                     > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                       > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < not | +0
[INFO] [stderr]                                                                                                                                                                                                                        > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                         < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                      < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                     < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                    < preceded | +1
[INFO] [stderr]                                                                                   < alt | +1
[INFO] [stderr]                                                                                  < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                  > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                                  < eof | +0
[INFO] [stderr]                  < delimited                        | +1
[INFO] [stderr]                                                                                                                                                                                                                 > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                  > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                   > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                            < Label("literal") | +10
[INFO] [stderr]                                                                                                                                                                                                                                           < Expected(Description("number")) | +10
[INFO] [stderr]                                                                                                                                                                                                                                          < alt | +10
[INFO] [stderr]                                                                                                                                                                                                                                          < preceded | +10
[INFO] [stderr]                                                                                                                                                                                                                                         < alt | +10
[INFO] [stderr]                                                                                                                                                                                                                                        < preceded | +10
[INFO] [stderr]                                                                                                                                                                                                              > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                               > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                              < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                              > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                                              < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > Label("extension") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                              > Self :: Extension | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                               > Label("record") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                > delimited | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                 > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                  > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                 > '{' | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < Label("extension") | backtrack
[INFO] [stderr]                     < alt                           | backtrack
[INFO] [stderr]                    < preceded                       | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                            > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                             > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                            > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                             > Self :: Let | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                              > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > Self :: Func | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                              > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > Label("record") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             > delimited | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                               > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                              > '{' | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > Self :: With | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             > "with" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                             > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              > not | "true"∅
[INFO] [stderr]                                                                                                                                                                                                               > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "if" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "else" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "while" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "return" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "break" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "continue" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                               < alt | +4
[INFO] [stderr]                                                                                                                                                                                                              < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                              > Expected(Description("number")) | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                              > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                               > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                 > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                 > Self :: Add | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                  > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                   > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                   > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                    > Self :: Let | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                     > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > Self :: Func | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                     > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > Label("record") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                     > delimited | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                      > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                       > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                        < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > Self :: With | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                      > "with" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     > preceded | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                      > multispace0 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                       > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                      > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                       > not | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                        > alt | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "let" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "if" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "else" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "while" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "return" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "break" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "continue" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "fun" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "true" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "false" | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                                                                       > Label("variable") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                        < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: Add | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: Let | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: Func | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Label("record") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > delimited | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > '{' | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: With | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                           > preceded | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                            > not | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                              > "let" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > "if" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > Label("record") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                              > delimited | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                               > '{' | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > Self :: With | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                              > "with" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                              > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > not | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "if" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "else" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "while" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "return" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > '{' | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > Self :: With | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                > "with" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > not | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "if" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > "else" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                   > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                    > not | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "if" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "else" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "while" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "return" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "break" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "continue" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                                                     < alt | +3
[INFO] [stderr]                                                                                                                                                                                                                                    < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > Expected(Description("number")) | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                     > Label("literal") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      > digit1 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                       > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                       < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > Label("boolean") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      > "true" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      > "false" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < Label("boolean") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     > "else" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                 < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > Label("literal") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > digit1 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                              < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    > Label("boolean") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                      < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                                                     < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                    < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                                                             < alt | +4
[INFO] [stderr]                                                                                                                                                                                                            < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                                       < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                      < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                                > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                                                                < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > Label("extension") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                > Self :: Extension | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > Label("record") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > delimited | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                   > '{' | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Label("extension") | backtrack
[INFO] [stderr]                                 < alt               | backtrack
[INFO] [stderr]                                < preceded           | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                              > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                              > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                               > Self :: Let | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > Self :: Func | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > Label("record") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                > delimited | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > '{' | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > alpha1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > '{' | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                           < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                          < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > Self :: With | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                > "with" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                > "break" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                               < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                              < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                               > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                               > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                                                                > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                  < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                  | verify | 
[INFO] [stderr]                                                                                                                                                                                                                                 < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                                < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                              < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                           < Label("body expression") | +1
[INFO] [stderr]                                                                                                                                                                                          < Expected(Description("expression")) | +1
[INFO] [stderr]                                                                                                                                                                                         < cut_err | +1
[INFO] [stderr]                                                                                                                                                                                                                       > cut_err | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > Expected(CharLiteral(';')) | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > Label("missing semicolon") | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > space0 | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > ';' | "; x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < ';' | +1
[INFO] [stderr]                                                                                                                                                                                                                          > space0 | " x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | " x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                          < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                                         < Label("missing semicolon") | +2
[INFO] [stderr]                                                                                                                                                                                                                        < Expected(CharLiteral(';')) | +2
[INFO] [stderr]                                                                                                                                                                                                                       < cut_err | +2
[INFO] [stderr]                                                                                                                                                                                                                       > Expected(Description("expression")) | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > Label("tail expression") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > "with" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > "while" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > not | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                                       > "while" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "return" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "break" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "continue" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "true" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             > "false" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < not | +0
[INFO] [stderr]                                                                                                                                                                                                                           > Label("variable") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > alpha1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Expected(Description("number")) | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > Label("literal") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > digit1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                             < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                             | verify | 
[INFO] [stderr]                                                                                                                                                                                                                            < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                           < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                   < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                  < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "continue" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "true" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > "false" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                                                      > Label("variable") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                       > alpha1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Expected(Description("number")) | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                       > Label("literal") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: Add | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                         > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > Expected(Description("number")) | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                          > Label("literal") | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                           > digit1 | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "2"∅
[INFO] [stderr]                                                                                                                                                                                                                            < eof | +0
[INFO] [stderr]                                                                                                                                                                                                                             > "if" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                             < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     > Label("atom") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                              < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                     < Label("atom") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Label("term") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                            > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: With | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > "return" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                       > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                           < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       > multispace0 | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > "+" | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                 < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Label("record access") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: RecordAccess | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                             > digit1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                          < delimited                | +7
[INFO] [stderr]                                                                                                                                                                                                                              > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                              > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                               > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                               > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                          > "else" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "with" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                            < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > preceded | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                            > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > "break" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > "continue" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            | verify | 
[INFO] [stderr]                                                                                                                                                                                                                            > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "while" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "return" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                  > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > Self :: Let | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > Self :: Func | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > Label("record") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > delimited | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                      > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                     > '{' | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > Self :: With | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > "with" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                    > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                     > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                              < eof | +0
[INFO] [stderr]                                                                                                                                                                                                                                > Self :: Add | "x123"∅
[INFO] [stdout] test tests::test_record_access ... ok
[INFO] [stderr]                                                                                                                                                                                                                                    > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Label("term") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                             < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                   | verify | 
[INFO] [stderr]                                                                                                                                                                                                                       < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                      < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                             > space0 | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > '(' | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                             < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > Label("extension") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > Self :: Extension | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > Label("record") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > delimited | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                > '{' | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                          < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                         < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > Self :: Let | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > Self :: Func | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            > Label("record") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > delimited | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                               > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > not | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "if" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "else" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "while" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                                 > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > not | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                          < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                         < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                      < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                      > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                > preceded | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                  > "return" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "break" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "continue" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "true" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 > "false" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                                                               > Label("variable") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > alpha1 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                               < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                       < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                           > multispace0 | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                           > "+" | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > Label("record access") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: RecordAccess | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > Self :: Let | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                             > '{' | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > Self :: With | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > "with" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           > preceded | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                            > multispace0 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                            > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                             > not | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                              > alt | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > "let" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "if" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "else" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "while" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "return" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "break" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "continue" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "fun" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "true" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               > "false" | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < not | +0
[INFO] [stderr]                                                                                                                                                                                                                              > Label("variable") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > alpha1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              > Expected(Description("number")) | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                               > Label("literal") | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                > digit1 | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > take_while | "1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                                < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                                | verify | 
[INFO] [stderr]                                                                                                                                                                                                                               < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                              < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                        < alt | +1
[INFO] [stderr]                                                                                                                                                                                                       < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                        > space0 | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                         > take_while | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                        < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                        > ')' | ")"∅
[INFO] [stderr]                                                                                                                                                                                                                        < ')' | +1
[INFO] [stderr]                                                                                                                                < Self :: Call | +6
[INFO] [stderr]                                          < alt      | +6
[INFO] [stderr]                                                                                                                                                                                                                                    > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                       > not | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                        > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "if" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "else" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "while" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "return" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "break" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "continue" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "true" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   > Self :: Call | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                    > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                     > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                      > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Let | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                       > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      > Self :: Func | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                       > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                                       < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                                       > space0 | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > '(' | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                                                       < '(' | +1
[INFO] [stderr]                                                                                                                                                                                                                       > space0 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                        > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                                       > not | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                        > alt | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                         > "let" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "if" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  > "fun" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         > "true" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                                                > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: Func | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Label("record") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         > delimited | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                          > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                          > '{' | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Self :: With | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "with" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                                 > multispace0 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                          > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                                   > "break" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "continue" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "true" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          > "false" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                                        > Label("variable") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                         > alpha1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                         < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        > Expected(Description("number")) | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                         > Label("literal") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                          > digit1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                           > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                                          < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                                          | verify | 
[INFO] [stderr]                                                                                                                                                                                                                         < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                                        < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                    > '.' | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                    < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                       < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                      < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  > Self :: Call | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                   > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                    > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                     > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                    > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                        > "false" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                                                                  > Label("variable") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                   > alpha1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   > alt | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    > "let" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "if" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "else" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "while" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "return" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "break" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "continue" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "fun" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "true" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    > "false" | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                                                  > Label("variable") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                   > alpha1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                    > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                                                     < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                    < preceded | +1
[INFO] [stderr]                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                           < preceded | +1
[INFO] [stderr]                                                 < Self :: Add | +5
[INFO] [stderr]                                                < alt | +5
[INFO] [stdout] test tests::test_add ... ok
[INFO] [stderr]           < preceded                                | +5
[INFO] [stderr]          < alt                                      | +5
[INFO] [stderr]         < preceded                                  | +5
[INFO] [stderr]                                                                                                                                                                                                            > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                            < eof | +0
[INFO] [stderr] < delimited                                         | +5
[INFO] [stderr]                                                                                                                                                                                                           > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                           < eof | +0
[INFO] [stderr]                                                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                          > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                         < preceded  | +6
[INFO] [stderr]                                        < alt        | +6
[INFO] [stderr]                                       < preceded    | +6
[INFO] [stderr]                                                                                                                                                                                                      > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                      < eof | +0
[INFO] [stderr]     < delimited                                     | +6
[INFO] [stderr]                                                                                                                                                                                                     > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                     < eof | +0
[INFO] [stderr]                                                                                                                                                                                                                         < "with" | backtrack
[INFO] [stdout] test tests::test_call ... ok
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                    > Self :: Let | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                                         > "else" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                                                     > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Let | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Func | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > Label("record") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                       > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                        > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                       > '{' | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                       < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > Self :: With | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > "with" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                       > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                      > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                       > not | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                        > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                         > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                         > "if" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                           > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                           < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                          > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                           > not | "true"∅
[INFO] [stderr]                                                                                                                                                                                                            > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             > "let" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "if" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "else" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "while" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "return" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "break" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "continue" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "fun" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                             > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                            < alt | +4
[INFO] [stderr]                                                                                                                                                                                                           < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > Expected(Description("number")) | "true"∅
[INFO] [stderr]                                                                                                                                                                                                            > Label("literal") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                             > digit1 | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              > take_while | "true"∅
[INFO] [stderr]                                                                                                                                                                                                              < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                            < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > Label("boolean") | "true"∅
[INFO] [stderr]                                                                                                                                                                                                            > alt | "true"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "false" | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                                                          > Label("variable") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                           > alpha1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                            > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                            < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                          < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                          > Expected(Description("number")) | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                           > Label("literal") | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                            > digit1 | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                             > take_while | "3, y = false, z = 5};\nl
[INFO] [stderr]                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                            < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                            | verify | 
[INFO] [stderr]                                                                                                                                                                                                           < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                          < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                      < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                    > opt | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                     > space0 | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                      > take_while | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                     > "," | ", y = false, z = 5};\nle
[INFO] [stderr]                                                                                                                                                                                                     < "," | +1
[INFO] [stderr]                                                                                                                                                                                                     > space0 | " y = false, z = 5};\nlet
[INFO] [stderr]                                                                                                                                                                                                      > take_while | " y = false, z = 5};\nlet
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                     < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                    < opt | +2
[INFO] [stderr]                                                                                                     <  | +7
[INFO] [stderr]                                                                                                    < Label("record field") | +7
[INFO] [stderr]                                                                                                                                                                                                  > Label("record field") | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   >  | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                    > not | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                     > alt | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "if" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "else" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                                  < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > Expected(Description("number")) | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                       > Label("literal") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                        > digit1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                        < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                        | verify | 
[INFO] [stderr]                                                                                                                                                                                                       < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                      < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                  > '.' | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                  < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: Call | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                   > Self :: Let | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > "else" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                           < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "while" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "return" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "break" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "continue" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "true" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "false" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                                                 > Label("variable") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  > alpha1 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "123"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +3
[INFO] [stderr]                                                                                                                                                                                                 < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                                      < alt | +4
[INFO] [stderr]                                                                                                                                                                                                     < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                    < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                    < preceded | +4
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                                   < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "true" | "true"∅
[INFO] [stderr]                                                                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "while" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "return" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "break" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "continue" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "true" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "false" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                             < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Self :: Func | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Label("record") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > delimited | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: With | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             > "with" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                          > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: Func | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Label("record") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > delimited | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: With | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > "with" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                            > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > not | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "if" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > not | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "if" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "else" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "while" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "return" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "break" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "continue" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "true" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "false" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                                  > Label("variable") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Expected(Description("number")) | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                                       > "return" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                            < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                  > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                                 > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                  > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                                                      < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                            < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                        < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("record access") | "x"∅
[INFO] [stderr]                                                                                                                                                                                            > Self :: RecordAccess | "x"∅
[INFO] [stderr]                                                                                                                                                                                             > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                               > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                               > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < not | +0
[INFO] [stderr]                                                                                                                                                                                                 > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                              > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "break" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "continue" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "true" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "false" | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                                 > Label("variable") | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                  > alpha1 | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "y = false, z = 5};\nlet 
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                  > take_while | " = false, z = 5};\nlet f
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                 > space0 | " = false, z = 5};\nlet f
[INFO] [stderr]                                                                                                                                                                                                  > take_while | " = false, z = 5};\nlet f
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                 < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                 > "=" | "= false, z = 5};\nlet f 
[INFO] [stderr]                                                                                                                                                                                                 < "=" | +1
[INFO] [stderr]                                                                                                                                                                                                 > space0 | " false, z = 5};\nlet f =
[INFO] [stderr]                                                                                                                                                                                                  > take_while | " false, z = 5};\nlet f =
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                 < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Add | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "else" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "while" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "return" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "break" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "continue" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "true" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "false" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                              < not | +0
[INFO] [stderr]                                                                                                                                                                                                   > Label("variable") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > alpha1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Expected(Description("number")) | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > Label("literal") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > digit1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                     < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                     | verify | 
[INFO] [stderr]                                                                                                                                                                                                    < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                   < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                               > space0 | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > alpha1 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                   < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                           > '.' | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                                                          < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                         > Self :: Call | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                           > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > Self :: Let | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: Func | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Label("record") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > delimited | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: With | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    > Label("literal") | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                             > digit1 | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "1234567890"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +10
[INFO] [stderr]                                                                                                                                                                                             < digit1 | +10
[INFO] [stderr]                                                                                                                                                                                             | verify | 
[INFO] [stderr]                                                                                                                                                                                                    < Label("literal") | +10
[INFO] [stderr]                                                                                                                                                                                                   < Expected(Description("number")) | +10
[INFO] [stderr]                                                                                                                                                                                                                                 < alt | +10
[INFO] [stderr]                                                                                                                                                                                                                            < preceded | +10
[INFO] [stderr]                                                                                                                                                                                                            < alt | +10
[INFO] [stderr]                                                                                                                                                                                                           < preceded | +10
[INFO] [stderr]                   < alt                             | +10
[INFO] [stderr]                 < preceded                          | +10
[INFO] [stderr]                                                                                                                                                                                                            < alt | +4
[INFO] [stderr]                                                                                                                                                                                                           < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                                                          < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                              < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                             < preceded | +4
[INFO] [stderr]                               < alt                 | +4
[INFO] [stderr]                              < preceded             | +4
[INFO] [stderr]                                                                                                                                                                              > eof | ""∅
[INFO] [stderr]                                                                                                                                                                              < eof | +0
[INFO] [stderr]  < delimited                                        | +4
[INFO] [stderr]                                                                                                                                                                             > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                              > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                  > Self :: Add | "false"∅
[INFO] [stderr]                                                                                                                                                                                   > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                     > Self :: Let | "false"∅
[INFO] [stderr]                                                                                                                                                                                      > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                     > Self :: Func | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > not | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                         > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "if" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "else" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "while" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "return" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "break" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "continue" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "true" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "false" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                        < not | +0
[INFO] [stderr]                                                                                                                                                                                        > Label("variable") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                         > alpha1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                         < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                              < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                        > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                                   > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                   < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Self :: Call | "x"∅
[INFO] [stderr]                                                                                                                                                                                  > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > "with" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                 > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > not | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "if" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "else" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "while" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "return" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "break" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "continue" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "true" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "false" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                                                   > Label("variable") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                    > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                                  > Label("variable") | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                   > alpha1 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                    > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                   < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                   > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                  > space0 | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                  > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                        < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                                                < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                     > '(' | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                  > space0 | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                                  > '(' | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Label("extension") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > Self :: Extension | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > Label("record") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    > delimited | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                     > '{' | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                                               < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                               > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 > Self :: Let | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Self :: Func | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Label("record") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > delimited | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > Expected(Description("number")) | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > Label("literal") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > digit1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                    < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                    | verify | 
[INFO] [stderr]                                                                                                                                                                                   < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                  < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                              > space0 | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < space0 | +0
[INFO] [stderr]                                                                                                                                                                              > '(' | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                              < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                             > Label("extension") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                              > Self :: Extension | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               > Label("record") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                > delimited | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > '{' | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                             < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                               < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                            > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                     > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                     < eof | +0
[INFO] [stderr]      < delimited                                    | +10
[INFO] [stderr]                                                                                                                                                                            > delimited | "123s"∅
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                              > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                              > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                               > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > Self :: Add | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                   > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > Self :: Let | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Self :: Func | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Label("record") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > delimited | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > '{' | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Self :: With | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > "with" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                   > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > not | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "if" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "else" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "while" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                        > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                        > Self :: Let | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Self :: Func | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Label("record") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         > delimited | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                          > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                           > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > '{' | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Self :: With | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         > "with" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                        > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                          > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    > Label("record access") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                           > Self :: RecordAccess | "x123"∅
[INFO] [stderr]                                                                                                                                                                                            > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              > Self :: Let | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Self :: Func | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Label("record") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > '{' | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Self :: With | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > "with" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                              > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > not | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                 > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "if" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "else" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "while" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "return" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "break" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "continue" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                 < alt | +5
[INFO] [stderr]                                                                                                                                                                                                < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Expected(Description("number")) | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                 > Label("literal") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  > digit1 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                   < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                  > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > ':' | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                  < ':' | +1
[INFO] [stderr]                                                                                                                                                                                                  > space0 | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                   > take_while | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                  > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                   > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                    > delimited | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                     > "{" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                     < "{" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                    >  | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                     > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                      > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                      < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                     < alt | +3
[INFO] [stderr]                                                                                                                                                                                                     > "->" | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                     < "->" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    <  | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                    > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                    < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                   < alt | +3
[INFO] [stderr]                                                                                                                                                                                                  < alt | +3
[INFO] [stderr]                                                                                                                                                                                                  > space0 | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > ')' | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                  < ')' | backtrack
[INFO] [stderr]                                                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Label("record") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 > delimited | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > '{' | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: With | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 > "with" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                  > not | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "if" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "else" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "while" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "return" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "break" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "continue" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                   < alt | +3
[INFO] [stderr]                                                                                                                                                                                                  < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Expected(Description("number")) | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > Label("literal") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    > digit1 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("boolean") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    > "true" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "false" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("boolean") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("atom") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("atom") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("term") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Label("term") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                    < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                                   < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Label("extension") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                              > Self :: Extension | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                            > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: With | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "with" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                            > preceded | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > not | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > alt | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                > "let" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "if" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "else" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "while" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "return" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "break" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                > "continue" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                                  < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Label("extension") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Extension | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > Label("record") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > delimited | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                     > '{' | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                            < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                               > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > Self :: Let | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Self :: Func | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Label("record") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > delimited | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > '{' | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Self :: With | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > "with" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("boolean") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                 > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                 < alt | +5
[INFO] [stderr]                                                                                                                                                                                                < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                               < alt | +5
[INFO] [stderr]                                                                                                                                                                                        < preceded | +5
[INFO] [stderr]                                                                                                                                                                                       < alt | +5
[INFO] [stderr]                                                                                                                                                                                                < preceded | +5
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                                             > take_while | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > "+" | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                                            < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("record access") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            > Self :: RecordAccess | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                             > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                               > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                               > Self :: Let | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Label("record") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                     > '{' | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Self :: With | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    > "with" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     > not | "false"∅
[INFO] [stderr]                                                                                                                                                                                                      > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "if" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "else" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "while" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "return" | "false"∅
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                        > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                       > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                        > Self :: Let | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > Self :: Func | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > Label("record") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > delimited | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                          > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                           > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                          > '{' | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > Self :: With | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > "with" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > preceded | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                         > multispace0 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                          > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                         > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                          > not | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                           > alt | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            > "let" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "if" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "else" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "while" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "return" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "break" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "continue" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "fun" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "true" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                            > "false" | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                          < not | +0
[INFO] [stderr]                                                                                                                                                                                                          > Label("variable") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                           > alpha1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                          < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                          > Expected(Description("number")) | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                           > Label("literal") | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                            > digit1 | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                             > take_while | "3, y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                            < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                            | verify | 
[INFO] [stderr]                                                                                                                                                                                                > "fun" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > "true" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                           < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                           > "false" | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                           < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                              < not | +0
[INFO] [stderr]                                                                                                                                                                                                         > Label("variable") | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                          > alpha1 | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                           > take_while | "x; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                          < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                          > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                         < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < Label("body expression") | +1
[INFO] [stderr]                                                                                                                                                                                                                                           < Expected(Description("expression")) | +1
[INFO] [stderr]                                                                                                                                                                                                                                          < cut_err | +1
[INFO] [stderr]                                                                                                                                                                                                > cut_err | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 > Expected(CharLiteral(';')) | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > Label("missing semicolon") | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > space0 | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       > "return" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "break" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "continue" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "true" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "false" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                                                                                                  > Label("variable") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                   > alpha1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Expected(Description("number")) | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                   > Label("literal") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                    > digit1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +3
[INFO] [stderr]                                                                                                                                                                                                    < digit1 | +3
[INFO] [stderr]                                                                                                                                                                                                    | verify | 
[INFO] [stderr]                                                                                                                                                                                                   < Label("literal") | +3
[INFO] [stderr]                                                                                                                                                                                                  < Expected(Description("number")) | +3
[INFO] [stderr]                                                                                                                                                                                    < alt | +3
[INFO] [stderr]                                                                                                                                                                                   < preceded | +3
[INFO] [stderr]                                                                                                                                                                                   < alt | +3
[INFO] [stderr]                                                                                                                                                                                  < preceded | +3
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "s"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "s"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > "+" | "s"∅
[INFO] [stderr]                                                                                                                                                                                              < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Label("record access") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                              > Self :: RecordAccess | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                             > not | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "if" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "else" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "while" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "return" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "break" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "continue" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "true" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                               > "false" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                             < not | +0
[INFO] [stderr]                                                                                                                                                                                             > Label("variable") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              > alpha1 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +1
[INFO] [stderr]                                                                                                                                                                                              < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                              > take_while | "123"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +3
[INFO] [stderr]                                                                                                                                                                                             < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                            < alt | +4
[INFO] [stderr]                                                                                                                                                                                              < preceded | +4
[INFO] [stderr]                                                                                                                                                                                             < alt | +4
[INFO] [stderr]                                                                                                                                                                                            < preceded | +4
[INFO] [stderr]                                                                                                                                                                                         > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                         < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Self :: Call | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                       > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                        > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                         > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < take_while | +1
[INFO] [stderr]                                                                                                                                                                                        < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                        > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                  < preceded | +1
[INFO] [stderr]                                                                                                                                                                                   > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                   > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                   < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Label("extension") | "x"∅
[INFO] [stderr]                                                                                                                                                                                   > Self :: Extension | "x"∅
[INFO] [stderr]                                                                                                                                                                                    > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                     > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                      > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                      < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                           < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                 > Label("record") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                      > delimited | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                        > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > '{' | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                       < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                      < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                 < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                 > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                   > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                   > Self :: Let | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                    > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: Func | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Label("record") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   > delimited | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                     > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > '{' | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: With | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   > "with" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                  > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                    > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                   > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                    > not | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                     > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "if" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "else" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "while" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                       > Self :: Let | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Self :: Func | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Label("record") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > '{' | "x123"∅
[INFO] [stderr]                                                                                                                                                                                         < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                        < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Self :: With | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > "with" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                       > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                        > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                         > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                       > ';' | "; true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                       < ';' | +1
[INFO] [stderr]                                                                                                                                                                                         > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         > "return" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "break" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "continue" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                      > Self :: Func | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                   < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                        > preceded | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          > not | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                           > alt | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            > "let" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "if" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "else" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "while" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "return" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "break" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "continue" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "fun" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "true" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "false" | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                           < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                          < not | +0
[INFO] [stderr]                                                                                                                                                                                          > Label("variable") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                           > alpha1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                           < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Expected(Description("number")) | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                           > Label("literal") | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            > digit1 | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | "3, y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                        > "break" | "false"∅
[INFO] [stderr]                                                                                                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "continue" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                      < alt | +5
[INFO] [stderr]                                                                                                                                                                                                     < not | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Expected(Description("number")) | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > Label("literal") | "false"∅
[INFO] [stderr]                                                                                                                                                                                             > digit1 | "false"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                             < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("boolean") | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                             > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "false" | +5
[INFO] [stderr]                                                                                                                                                                                            < alt | +5
[INFO] [stderr]                                                                                                                                                                                           < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                                    < alt | +5
[INFO] [stderr]                                                                                                                                                                                                   < preceded | +5
[INFO] [stderr]                                                                                                                                                                                    < alt | +5
[INFO] [stderr]                                                                                                                                                                                   < preceded | +5
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                       < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Label("record access") | "false"∅
[INFO] [stderr]                                                                                                                                                                                     > Self :: RecordAccess | "false"∅
[INFO] [stderr]                                                                                                                                                                                      > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                        > Self :: Let | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Self :: Func | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Label("record") | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                           > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > '{' | "false"∅
[INFO] [stderr]                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Self :: With | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > "with" | "false"∅
[INFO] [stderr]                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                        > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > not | "false"∅
[INFO] [stderr]                                                                                                                                                                                           > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "if" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "else" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "while" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "return" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "break" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "continue" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > space0 | " true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | " true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                       < space0 | +1
[INFO] [stderr]                                                                                                                                                                                                  < Label("missing semicolon") | +2
[INFO] [stderr]                                                                                                                                                                                                 < Expected(CharLiteral(';')) | +2
[INFO] [stderr]                                                                                                                                                                                                < cut_err | +2
[INFO] [stderr]                                                                                                                                                                                         > Expected(Description("expression")) | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          > Label("tail expression") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > Self :: Add | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Let | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Func | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("record") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > delimited | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                          < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                       < alt | +1
[INFO] [stderr]                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                                               > opt | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > space0 | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                > "," | ", y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                < "," | +1
[INFO] [stderr]                                                                                                                                                                                                > space0 | " y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | " y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                < space0 | +1
[INFO] [stderr]                                                                                                                                                                                               < opt | +2
[INFO] [stderr]                                                                                                                                                                                                                                               <  | +7
[INFO] [stderr]                                                                                                                                                                                                                                              < Label("record field") | +7
[INFO] [stderr]                                                                                                                                                                                             > Label("record field") | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              >  | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               > not | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > alt | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "if" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "else" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "while" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "return" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "break" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "continue" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "true" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "false" | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                        > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                       < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                           < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                              > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > Self :: Let | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: Func | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("record") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > delimited | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > '{' | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: With | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > "with" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                > preceded | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                  > not | "x"∅
[INFO] [stderr]                                                                                                                                                                                                   > alt | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "if" | "x"∅
[INFO] [stderr]                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    > not | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                     > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "if" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "else" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "return" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "break" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "continue" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "true" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "false" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                                   > Label("variable") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    > alpha1 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                     > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    < "false" | +5
[INFO] [stderr]                                                                                                                                                                                           < alt | +5
[INFO] [stderr]                                                                                                                                                                                          < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Expected(Description("number")) | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   > Label("literal") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                    > digit1 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("boolean") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Let | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                       > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < "false" | +5
[INFO] [stderr]                                                                                                                                                                                            < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                       | verify | 
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                    < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "123"∅
[INFO] [stderr]                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                   < alt | +5
[INFO] [stderr]                                                                                                                                                                                                  < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                         < alt | +5
[INFO] [stderr]                                                                                                                                                                                        < preceded | +5
[INFO] [stderr]                                                                                                                                                                                       < alt | +5
[INFO] [stderr]                                                                                                                                                                                      < preceded | +5
[INFO] [stderr]                                                                                                                                                                                             > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                             < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Self :: Call | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                              > Self :: Let | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Self :: Func | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Label("record") | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > '{' | "false"∅
[INFO] [stderr]                                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                              > Self :: With | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > "with" | "false"∅
[INFO] [stderr]                                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                              > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                > not | "false"∅
[INFO] [stderr]                                                                                                                                                                                                 > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "if" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "else" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "while" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "return" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "break" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "continue" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                 < alt | +5
[INFO] [stderr]                                                                                                                                                                                                < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Expected(Description("number")) | "false"∅
[INFO] [stderr]                                                                                                                                                                                                 > Label("literal") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  > digit1 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("boolean") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                 > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                  < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                 < alt | +5
[INFO] [stderr]                                                                                                                                                                                                < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                               < alt | +5
[INFO] [stderr]                                                                                                                                                                                              < preceded | +5
[INFO] [stderr]                                                                                                                                                                                             < alt | +5
[INFO] [stderr]                                                                                                                                                                                            < preceded | +5
[INFO] [stderr]                                                                                                                                                                                            > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < space0 | +0
[INFO] [stderr]                                                                                                                                                                                            > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                            < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("extension") | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > Self :: Extension | "false"∅
[INFO] [stderr]                                                                                                                                                                                             > Label("record") | "false"∅
[INFO] [stderr]                                                                                                                                                                                              > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > '{' | "false"∅
[INFO] [stderr]                                                                                                                                                                                               < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                          < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                         < alt | +1
[INFO] [stderr]                                                                                                                                                                                        < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                           < alt | +1
[INFO] [stderr]                                                                                                                                                                                                          < preceded | +1
[INFO] [stderr]                                                                                                                                                                                        > opt | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > space0 | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < space0 | +0
[INFO] [stderr]                                                                                                                                                                                         > "," | ", y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         < "," | +1
[INFO] [stderr]                                                                                                                                                                                         > space0 | " y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | " y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +1
[INFO] [stderr]                                                                                                                                                                                         < space0 | +1
[INFO] [stderr]                                                                                                                                                                                        < opt | +2
[INFO] [stderr]                                                                                                                                                                                                                       <  | +7
[INFO] [stderr]                                                                                                                                                                                         < Label("record field") | +7
[INFO] [stderr]                                                                                                                                                                                      > Label("record field") | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                       >  | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                        > not | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > alt | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          > "let" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "if" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "else" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "while" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "return" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "break" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "continue" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "fun" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "true" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                         > Label("variable") | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          > alpha1 | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                           > take_while | "y = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                           < take_while | +1
[INFO] [stderr]                                                                                                                                                                                          < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                          > take_while | " = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                         > space0 | " = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | " = 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > '{' | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                        > Self :: With | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                         > "with" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                         < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                        > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          > not | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "if" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "else" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "while" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "return" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "break" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "continue" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "true" | +4
[INFO] [stderr]                                                                                                                                                                                           < alt | +4
[INFO] [stderr]                                                                                                                                                                                          < not | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Expected(Description("number")) | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           > Label("literal") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > digit1 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                       > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                        > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                        > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                         > Self :: Let | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                          < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                         > Self :: Func | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                          < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                         > Label("record") | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > delimited | "false"∅
[INFO] [stderr]                                                                                                                                                                                           > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                           > '{' | "false"∅
[INFO] [stderr]                                                                                                                                                                                           < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                          < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                          > "else" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +3
[INFO] [stderr]                                                                                                                                                                                         < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                         > space0 | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                          > take_while | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < space0 | +0
[INFO] [stderr]                                                                                                                                                                                         > '(' | "(x: number) { x + 1 };\n
[INFO] [stderr]                                                                                                                                                                                         < '(' | +1
[INFO] [stderr]                                                                                                                                                                                         > space0 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                          > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < space0 | +0
[INFO] [stderr]                                                                                                                                                                                         > not | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                          > alt | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                           > "let" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                           < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                           > "if" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                           < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                           > "else" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                           < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < alt | +5
[INFO] [stderr]                                                                                                                                                                                    < not | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Expected(Description("number")) | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                           > Label("literal") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            > digit1 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                             > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                             < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                            < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Label("boolean") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                           > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                            > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            < "false" | +5
[INFO] [stderr]                                                                                                                                                                                           < alt | +5
[INFO] [stderr]                                                                                                                                                                                          < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                   < alt | +5
[INFO] [stderr]                                                                                                                                                                                  < preceded | +5
[INFO] [stderr]                                                                                                                                                                                              < alt | +5
[INFO] [stderr]                                                                                                                                                                                             < preceded | +5
[INFO] [stderr]                                                                                                                                                                                      > '.' | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                                          < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                     > Self :: Func | "123s"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +1
[INFO] [stderr]                                                                                                                                                                                          > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                      > "false" | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                         < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                        < not | +0
[INFO] [stderr]                                                                                                                                                                                   > Label("variable") | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "y=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                    > take_while | "=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                   > space0 | "=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                                   > "=" | "=2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   < "=" | +1
[INFO] [stderr]                                                                                                                                                                                                   < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                                   < alt | +4
[INFO] [stderr]                                                                                                                                                                                       < preceded | +4
[INFO] [stderr]                                                                                                                                                                                      < alt | +4
[INFO] [stderr]                                                                                                                                                                                        < preceded | +4
[INFO] [stderr]                                                                                                                                                                               > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                         < space0 | +1
[INFO] [stderr]                                                                                                                                                                                > "=" | "= 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                < "=" | +1
[INFO] [stderr]                                                                                                                                                                                > space0 | " 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | " 2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                < space0 | +1
[INFO] [stderr]                                                                                                                                                                                > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                   > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > Self :: Add | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                      > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                       > Self :: Let | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Self :: Func | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Label("record") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > delimited | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                         > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                         > '{' | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                         < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                        < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                       > Self :: With | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        > "with" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                        < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                      < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "while" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                       > "return" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "while" | "x"∅
[INFO] [stderr]                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "return" | "x"∅
[INFO] [stderr]                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "break" | "x"∅
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                     > Label("record") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > delimited | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > '{' | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                      < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                     > Self :: With | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > "with" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                     > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                      > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                       > not | "123s"∅
[INFO] [stderr]                                                                                                                                                                                        > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "if" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "else" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "while" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "return" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "break" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "continue" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                         < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                               > space0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                         > Self :: Call | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < space0 | +0
[INFO] [stderr]                                                                                                                                                                                       < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                         > "true" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                          > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                         > Self :: With | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > "with" | "false"∅
[INFO] [stderr]                                                                                                                                                                                          < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                         > preceded | "false"∅
[INFO] [stderr]                                                                                                                                                                                          > multispace0 | "false"∅
[INFO] [stderr]                                                                                                                                                                                           > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                           > not | "false"∅
[INFO] [stderr]                                                                                                                                                                                            > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                             > "let" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                          > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                          < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                         > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               > not | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "if" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "else" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "while" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "return" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "break" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "continue" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "true" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "false" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                               > Label("variable") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > alpha1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                         < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < space0 | +0
[INFO] [stderr]                                                                                                                                                                                               > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > Self :: Add | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                     > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > Self :: Let | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > Self :: Func | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > Label("record") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       > delimited | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                        > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                         > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > "if" | "false"∅
[INFO] [stderr]                                                                                                                                                                                             < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "else" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "while" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "return" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "break" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "continue" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "fun" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "false" | +5
[INFO] [stderr]                                                                                                                                                                                            < alt | +5
[INFO] [stderr]                                                                                                                                                                                           < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > Expected(Description("number")) | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       > Label("literal") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        > digit1 | "false"∅
[INFO] [stderr]                                                                                                                                                                                                         > take_while | "false"∅
[INFO] [stderr]                                                                                                                                                                                                         < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                        < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                       < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > Label("boolean") | "false"∅
[INFO] [stderr]                                                                                                                                                                                                       > alt | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        > "true" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                        > "false" | "false"∅
[INFO] [stderr]                                                                                                                                                                                                        < "false" | +5
[INFO] [stderr]                                                                                                                                                                                                       < alt | +5
[INFO] [stderr]                                                                                                                                                                                                      < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                                          < alt | +5
[INFO] [stderr]                                                                                                                                                                                         < preceded | +5
[INFO] [stderr]                                                                                                                                                                                        < alt | +5
[INFO] [stderr]                                                                                                                                                                                       < preceded | +5
[INFO] [stderr]                                                                                                                                                                               < alt | +5
[INFO] [stderr]                                                                                                                                                                              < preceded | +5
[INFO] [stderr]                                                                                                                                                                                                > eof | ""∅
[INFO] [stderr]                                                                                                                                                                                                < eof | +0
[INFO] [stderr]                                                                                                                                                                             < delimited | +5
[INFO] [stderr]                                                                                                                                                                                               > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                      > "break" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "continue" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "true" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "false" | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                          < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                         < not | +0
[INFO] [stderr]                                                                                                                                                                                               > Label("variable") | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                > alpha1 | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x: number) { x + 1 };\n 
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                               > space0 | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                > take_while | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < space0 | +0
[INFO] [stderr]                                                                                                                                                                                               > ':' | ": number) { x + 1 };\n  
[INFO] [stderr]                                                                                                                                                                                               < ':' | +1
[INFO] [stderr]                                                                                                                                                                                               > space0 | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                > take_while | " number) { x + 1 };\n   
[INFO] [stderr]                                                                                                                                                                                                < take_while | +1
[INFO] [stderr]                                                                                                                                                                                               < space0 | +1
[INFO] [stderr]                                                                                                                                                                                               > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                 > delimited | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                  > "{" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                  < "{" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("boolean") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                                < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                                         < alt | +4
[INFO] [stderr]                                                                                                                                                                                        < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                                < preceded | +4
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | " }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | " }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +1
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +1
[INFO] [stderr]                                                                                                                                                                                            > "+" | "}; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                         > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                         < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                       < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Label("extension") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                           > Self :: Extension | "x123"∅
[INFO] [stderr]                                                                                                                                                                                            > Label("record") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                             > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "x123"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                           > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                           > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                            > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                              > Self :: Add | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > Self :: Let | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Self :: Func | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Label("record") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > '{' | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Self :: With | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > "with" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > "continue" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "true" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "false" | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                               > Label("variable") | "x"∅
[INFO] [stderr]                                                                                                                                                                                                > alpha1 | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x"∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                                > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                                              < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                                        < Label("tail expression") | +1
[INFO] [stderr]                                                                                                                                                                                                                       < Expected(Description("expression")) | +1
[INFO] [stderr]                                                                                                                          < Self :: Let | +12
[INFO] [stderr]                                                                                                                         < alt | +12
[INFO] [stderr]                                                                                                                        < preceded | +12
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                    < "+" | backtrack
[INFO] [stderr]                                                                                                                       < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Label("record access") | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > Self :: RecordAccess | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                      > preceded | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                       > multispace0 | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                        > take_while | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                                       < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                       > alt | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                        > Self :: Let | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                           > Label("record access") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                         > Self :: RecordAccess | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                          > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                           > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                           > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            > Self :: Let | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: Func | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Label("record") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > delimited | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > '{' | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                             < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Self :: With | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > "with" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                            > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                               > Self :: Let | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Self :: Func | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Label("record") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > delimited | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > '{' | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Self :: With | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > "with" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                               > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                                  >  | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                 > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                  > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                  < "num" | +3
[INFO] [stderr]                                                                                                                                                                                                 < alt | +3
[INFO] [stderr]                                                                                                                                                                                                 > "->" | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                                 < "->" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  <  | backtrack
[INFO] [stderr]                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                               > alt | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                > "num" | "number) { x + 1 };\n    
[INFO] [stderr]                                                                                                                                                                                                < "num" | +3
[INFO] [stderr]                                                                                                                                                                                               < alt | +3
[INFO] [stderr]                                                                                                                                                                                               < alt | +3
[INFO] [stderr]                                                                                                                                                                                              > space0 | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                               > take_while | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < space0 | +0
[INFO] [stderr]                                                                                                                                                                                              > ')' | "ber) { x + 1 };\n       
[INFO] [stderr]                                                                                                                                                                                              < ')' | backtrack
[INFO] [stderr]                                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Label("record") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                              > delimited | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > '{' | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                               < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                              < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Self :: With | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                              > "with" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                     > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > not | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "if" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > "let" | "let x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                               < "let" | +3
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                           < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                                < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Expected(Description("number")) | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > Label("literal") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                 > digit1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                 < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                 | verify | 
[INFO] [stderr]                                                                                                                                                                                                < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                               < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                         < preceded | +1
[INFO] [stderr]                                                                                                                                                                                      < alt | +1
[INFO] [stderr]                                                                                                                                                                                     < preceded | +1
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > "+" | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("record access") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > Self :: RecordAccess | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                                > '{' | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                             > Self :: With | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > "with" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                             > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                               > not | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "if" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "else" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "while" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > "return" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > space1 | " x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | " x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                 < space1 | +1
[INFO] [stderr]                                                                                                                                                                                                 > not | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                  > alt | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   > "let" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "if" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "else" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > preceded | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                    > not | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "if" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "else" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "return" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "break" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "continue" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                 < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "else" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "while" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "return" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "break" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "continue" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "true" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "false" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                                   > Label("variable") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > alpha1 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +4
[INFO] [stderr]                                                                                                                                                                                                    < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                                                    > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                              < alt | +4
[INFO] [stderr]                                                                                                                                                                                                 < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                < alt | +4
[INFO] [stderr]                                                                                                                                                                                               < preceded | +4
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                 > not | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                  > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "if" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "else" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "while" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "return" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "break" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "continue" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "true" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > "false" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                               < not | +0
[INFO] [stderr]                                                                                                                                                                                                > Label("variable") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > alpha1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Expected(Description("number")) | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > Label("literal") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > digit1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                                  < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                                  | verify | 
[INFO] [stderr]                                                                                                                                                                                                 < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                              < alt | +1
[INFO] [stderr]                                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                     < alt | +1
[INFO] [stderr]                                                                                                                                                                                                    < preceded | +1
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > "+" | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                                            < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                          > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                           > Self :: Let | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Self :: Func | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Label("record") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > delimited | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > '{' | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                            < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                           > Self :: With | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > "with" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                           > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                            > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                            > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                           > "fun" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                           < "fun" | +3
[INFO] [stderr]                                                                                                                                                                                                     < alt | +3
[INFO] [stderr]                                                                                                                                                                                                    < not | backtrack
[INFO] [stderr]                                                                                                                                                                                          > Expected(Description("number")) | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                           > Label("literal") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                            > digit1 | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                             > take_while | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "return" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                             < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "break" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                             < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "continue" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                             < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "fun" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                             < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                             > "true" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                             > "+" | ""∅
[INFO] [stderr]                                                                                                                                                                                             < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                                            > Label("record access") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                             > Self :: RecordAccess | "treu"∅
[INFO] [stderr]                                                                                                                                                                                              > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                          < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                                               < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                                              < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                              > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                               > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                           > Label("record access") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > Self :: RecordAccess | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Let | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > Self :: Func | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > Label("record") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                             < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                            < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                          < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                > Self :: Let | "treu"∅
[INFO] [stderr]                                                                                                                                                                                            > "break" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                            < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "continue" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                   < "true" | +4
[INFO] [stderr]                                                                                                                                                                                                  < alt | +4
[INFO] [stderr]                                                                                                                                                                                                 < not | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Expected(Description("number")) | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                                     > delimited | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                 > "false" | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Func | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("record") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > '{' | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Self :: With | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > "with" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > not | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "if" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "else" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "return" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "break" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "continue" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "true" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > "false" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                                     > Label("variable") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      > alpha1 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                       < take_while | +4
[INFO] [stderr]                                                                                                                                                                                                      < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                                                      > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                     < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                                   < alt | +4
[INFO] [stderr]                                                                                                                                                                                                  < preceded | +4
[INFO] [stderr]                                                                                                                                                                                               < alt | +4
[INFO] [stderr]                                                                                                                                                                                              < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                 > '.' | ""∅
[INFO] [stderr]                                                                                                                                                                                                 < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Self :: Call | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Let | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Self :: Func | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("record") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                    > '{' | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Self :: With | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > "with" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > not | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "if" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "else" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "while" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "return" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "break" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "continue" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "true" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "false" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                                    > Label("variable") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                     > alpha1 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                      < take_while | +4
[INFO] [stderr]                                                                                                                                                                                                     < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                                                     > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                                   < alt | +4
[INFO] [stderr]                                                                                                                                                                                                  < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                                < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                > space0 | ""∅
[INFO] [stderr]                                                                                                                                                                                                 > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < space0 | +0
[INFO] [stderr]                                                                                                                                                                                                > '(' | ""∅
[INFO] [stderr]                                                                                                                                                                                                < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                                               > Label("extension") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                > Self :: Extension | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                 > Label("record") | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                  > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > '{' | "treu"∅
[INFO] [stderr]                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                                               < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                            < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                             > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                                              > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                               > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                > Self :: Let | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: Func | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Label("record") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > delimited | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > '{' | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                > Self :: With | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > "with" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                > preceded | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                 > multispace0 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                 > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                  > not | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                   > alt | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    > "let" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "if" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "else" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "while" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > "return" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                       > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                   > '{' | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > Self :: With | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > "with" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                                 > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                  > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                                  > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                   > not | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "if" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "else" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "while" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "return" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "break" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "continue" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "true" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     > "false" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                                                                   > Label("variable") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                    > alpha1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                                   > Label("boolean") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     > alt | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      > "true" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                                      > "false" | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("boolean") | backtrack
[INFO] [stderr]                                                                                                                                                                                                    > Label("atom") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                     < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < Label("atom") | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("term") | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   > fail | "fun(x: number) { x + 1 }
[INFO] [stderr]                                                                                                                                                                                                   < fail | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("term") | backtrack
[INFO] [stderr]                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                 < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                               < preceded | backtrack
[INFO] [stderr]                                                                                                                                                              < Label("body expression") | backtrack
[INFO] [stderr]                                                                                                                                                             < Expected(Description("expression")) | backtrack
[INFO] [stderr]                                                                                                                                                            < cut_err | cut
[INFO] [stderr]                                                                     < Self :: Let | cut
[INFO] [stderr]                                                                    < alt | cut
[INFO] [stderr]                                                                   < preceded | cut
[INFO] [stderr]                                                                  < Self :: Add | cut
[INFO] [stderr]                                                                 < alt | cut
[INFO] [stderr]                                                                < preceded | cut
[INFO] [stderr]                                                               < alt | cut
[INFO] [stderr]                                                              < preceded | cut
[INFO] [stderr]         < delimited                                 | cut
[INFO] [stderr]                                                                                                                                                                                                > not | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "if" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "else" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "while" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "return" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "break" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "continue" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "true" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "false" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                 > Label("variable") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > alpha1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                  < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Expected(Description("number")) | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > Label("literal") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > digit1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                   < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                   | verify | 
[INFO] [stderr]                                                                                                                                                                                  < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                                 < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < not | +0
[INFO] [stderr]                                                                                                                                                                                > Label("variable") | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > alpha1 | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "x = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +1
[INFO] [stderr]                                                                                                                                                                                 < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                 > take_while | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < Label("variable") | +1
[INFO] [stderr]                                                                                                                                                                                > space0 | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | " = 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                < space0 | +1
[INFO] [stderr]                                                                                                                                                                                > '=' | "= 1; x"∅
[INFO] [stderr]                                                                                                                                                                                < '=' | +1
[INFO] [stderr]                                                                                                                                                                                > space0 | " 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | " 1; x"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                                < space0 | +1
[INFO] [stderr]                                                                                                                                                                                > cut_err | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > Expected(Description("expression")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                  > Label("body expression") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                    > "break" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "continue" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "true" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "false" | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                   > Label("variable") | "x123"∅
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "x123"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +1
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | +1
[INFO] [stderr]                                                                                                                                                                                    > take_while | "123"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +3
[INFO] [stderr]                                                                                                                                                                                   < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                                < preceded | +4
[INFO] [stderr]                                                                                                                                                                                               < alt | +4
[INFO] [stderr]                                                                                                                                                                                              < preceded | +4
[INFO] [stderr]                                                                                                                                                                                                                             < alt | +4
[INFO] [stderr]                                                                                                                                                                                                                                   < preceded | +4
[INFO] [stderr]                                                                                                                                                                             > eof | ""∅
[INFO] [stderr]                                                                                                                                                                             < eof | +0
[INFO] [stderr]                                                                                                                                                                                                                 < delimited | +4
[INFO] [stderr]                                                                                                                                                                            > delimited | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                              > Self :: Let | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: Func | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                              > Label("record") | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > delimited | "treu"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > '{' | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: With | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > "with" | "treu"∅
[INFO] [stderr]                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                              > preceded | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                > not | "treu"∅
[INFO] [stderr]                                                                                                                                                                                 > alt | "treu"∅
[INFO] [stderr]                                                                                                                                                                                  > "let" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "if" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "else" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                                  > Label("literal") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > digit1 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                   < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Label("boolean") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "true" | +4
[INFO] [stderr]                                                                                                                                                                                  < alt | +4
[INFO] [stderr]                                                                                                                                                                                 < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                                                < alt | +4
[INFO] [stderr]                                                                                                                                                                                            < preceded | +4
[INFO] [stderr]                                                                                                                                                                                           < alt | +4
[INFO] [stderr]                                                                                                                                                                                          < preceded | +4
[INFO] [stderr]                                                                                                                                                                             > '.' | " }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                             < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                           > Self :: Call | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                            > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              > Self :: Let | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: Func | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                              > Label("record") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > delimited | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > '{' | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: With | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > "with" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                              > preceded | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > not | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > "let" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "if" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Expected(Description("number")) | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > Label("literal") | "2, z=2}"∅
[INFO] [stdout] test tests::test_multiple_let ... FAILED
[INFO] [stderr]                                                                                                                                                                                   > digit1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +1
[INFO] [stderr]                                                                                                                                                                                   < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                   | verify | 
[INFO] [stderr]                                                                                                                                                                                  < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                 < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                                    < alt | +1
[INFO] [stderr]                                                                                                                                                                                                   < preceded | +1
[INFO] [stderr]                                                                                                                                                                             > '.' | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                             < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                           > Self :: Call | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                            > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                             > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                              > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                              > Self :: Let | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: Func | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                              > Label("record") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > delimited | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > '{' | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                              < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: With | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > "with" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                              > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                               > "while" | "treu"∅
[INFO] [stderr]                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "return" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "break" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "continue" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "fun" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "true" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                > "false" | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                              > Label("variable") | "treu"∅
[INFO] [stderr]                                                                                                                                                                               > alpha1 | "treu"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "treu"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +4
[INFO] [stderr]                                                                                                                                                                               < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                               > take_while | ""∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < Label("variable") | +4
[INFO] [stderr]                                                                                                                                                                               < alt | +4
[INFO] [stderr]                                                                                                                                                                               > "else" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > not | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                             > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               > Self :: Add | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                  > Self :: Let | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: Func | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Label("record") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   > delimited | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > '{' | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: With | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   > "with" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                  > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                                                        > "false" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                        < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                       < not | +0
[INFO] [stderr]                                                                                                                                                                                   > Label("variable") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                   > Expected(Description("number")) | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > Label("literal") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                     > digit1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | +3
[INFO] [stderr]                                                                                                                                                                                     < digit1 | +3
[INFO] [stderr]                                                                                                                                                                                     | verify | 
[INFO] [stderr]                                                                                                                                                                                    < Label("literal") | +3
[INFO] [stderr]                                                                                                                                                                                   < Expected(Description("number")) | +3
[INFO] [stderr]                                                                                                                                                                                      < alt | +3
[INFO] [stderr]                                                                                                                                                                                     < preceded | +3
[INFO] [stderr]                                                                                                                                                                                                    < alt | +3
[INFO] [stderr]                                                                                                                                                                                         < preceded | +3
[INFO] [stderr]                                                                                                                                                                               > '.' | "s"∅
[INFO] [stderr]                                                                                                                                                                               < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                              < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                             < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                             > Self :: Call | "123s"∅
[INFO] [stderr]                                                                                                                                                                              > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                               > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                               > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                > Self :: Let | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                > Self :: Func | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                > Label("record") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > delimited | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > '{' | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                     > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "if" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "else" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "while" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "return" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "break" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "continue" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "true" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                  > "false" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                < not | +0
[INFO] [stderr]                                                                                                                                                                                > Label("variable") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 > alpha1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                 < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                > Expected(Description("number")) | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                 > Label("literal") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                  > digit1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +1
[INFO] [stderr]                                                                                                                                                                                  < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                  | verify | 
[INFO] [stderr]                                                                                                                                                                                 < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                               < alt | +1
[INFO] [stderr]                                                                                                                                                                              < preceded | +1
[INFO] [stderr]                                                                                                                                                                                            > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                            < take_while | +0
[INFO] [stderr]                                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                            > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                             > not | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                              > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "if" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "else" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "while" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "return" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "break" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "continue" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                               > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               < "false" | +5
[INFO] [stderr]                                                                                                                                                                              < alt | +5
[INFO] [stderr]                                                                                                                                                                             < not | backtrack
[INFO] [stderr]                                                                                                                                                                             > Expected(Description("number")) | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                              > Label("literal") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                               > digit1 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                               < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                              < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                             < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                           > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                            > not | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                             > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "if" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "else" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "while" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "return" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "break" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "continue" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                              > "true" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                              < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                              > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                               > Self :: Add | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                  > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                    > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                  > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                  > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                   > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                    > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                      > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                     < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                    < not | +0
[INFO] [stderr]                                                                                                                                                                                    > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                     < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                    < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                    > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                     > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                      > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                       > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                       < take_while | +1
[INFO] [stderr]                                                                                                                                                                                      < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                      | verify | 
[INFO] [stderr]                                                                                                                                                                                     < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                    < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                   < alt | +1
[INFO] [stderr]                                                                                                                                                                                  < preceded | +1
[INFO] [stderr]                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "; x"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "; x"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > "+" | "; x"∅
[INFO] [stderr]                                                                                                                                                                                < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                               < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                                               > Label("record access") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                > Self :: RecordAccess | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                 > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                   > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                                                 < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                          < alt | +1
[INFO] [stderr]                                                                                                                                                                                             < preceded | +1
[INFO] [stderr]                                                                                                                                                                                > '.' | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                            < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                                           < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                                              > Self :: Call | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > Self :: Let | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Self :: Func | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Label("record") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > delimited | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                   > '{' | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Self :: With | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > "with" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                 > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                  > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > not | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "if" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "else" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "while" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "return" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "break" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "continue" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "true" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                     > "false" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                                                   > Label("variable") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                   < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                                   > Expected(Description("number")) | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                    > Label("literal") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                     > digit1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                      > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                      < take_while | +1
[INFO] [stderr]                                                                                                                                                                                     < digit1 | +1
[INFO] [stderr]                                                                                                                                                                                     | verify | 
[INFO] [stderr]                                                                                                                                                                                    < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                   < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                                      > "false" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "while" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "return" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "break" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "continue" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "fun" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                   > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "true" | +4
[INFO] [stderr]                                                                                                                                                                                 < alt | +4
[INFO] [stderr]                                                                                                                                                                                < not | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Expected(Description("number")) | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > Label("literal") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > digit1 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                    < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                   < digit1 | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Label("literal") | backtrack
[INFO] [stderr]                                                                                                                                                                                 < Expected(Description("number")) | backtrack
[INFO] [stderr]                                                                                                                                                                                 > Label("boolean") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                  > alt | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   > "true" | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                   < "true" | +4
[INFO] [stderr]                                                                                                                                                                                  < alt | +4
[INFO] [stderr]                                                                                                                                                                                 < Label("boolean") | +4
[INFO] [stderr]                                                                                                                                                                               < alt | +4
[INFO] [stderr]                                                                                                                                                                              < preceded | +4
[INFO] [stderr]                                                                                                                                                                             < alt | +4
[INFO] [stderr]                                                                                                                                                                            < preceded | +4
[INFO] [stderr]                                                                                                                                                                             > space0 | " }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              > take_while | " }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              < take_while | +1
[INFO] [stderr]                                                                                                                                                                             < space0 | +1
[INFO] [stderr]                                                                                                                                                                             > '(' | "}; f(1)"∅
[INFO] [stderr]                                                                                                                                                                             < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                           < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                            > Label("extension") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                             > Self :: Extension | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                              > Label("record") | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                               > delimited | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                > multispace0 | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 > take_while | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                                > Self :: With | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > "with" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                                < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                                > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                  > not | "123s"∅
[INFO] [stderr]                                                                                                                                                                                   > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "if" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "else" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "while" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "return" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "break" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "continue" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "true" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                                    > "false" | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                  < not | +0
[INFO] [stderr]                                                                                                                                                                                  > Label("variable") | "123s"∅
[INFO] [stderr]                                                                                                                                                                                    > Label("boolean") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                              < preceded | +4
[INFO] [stderr]                                                                                                                                                                             < alt | +1
[INFO] [stderr]                                                                                                                                                                                      < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                < alt | +1
[INFO] [stderr]                                                                                                                                                                               < preceded | +1
[INFO] [stderr]                                                                                                                                                                              > space0 | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               > take_while | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                                              < space0 | +0
[INFO] [stderr]                                                                                                                                                                              > '(' | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                              < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                             > Label("extension") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                              > Self :: Extension | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                               > Label("record") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                > delimited | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                                 > '{' | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                                < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                               < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                              < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                             < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                   < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                  < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                           > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                            > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                             > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                             < take_while | +0
[INFO] [stderr]                                                                                                                                                                            < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                            > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                                   > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                             > "true" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                             < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                             > "false" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                             < "false" | +5
[INFO] [stderr]                                                                                                                                                                                   < alt | +5
[INFO] [stderr]                                                                                                                                                                                    < Label("boolean") | +5
[INFO] [stderr]                                                                                                                                                                            < alt | +5
[INFO] [stderr]                                                                                                                                                                                               < preceded | +5
[INFO] [stderr]                                                                                                                                                                                              < alt | +5
[INFO] [stderr]                                                                                                                                                                                          < preceded | +5
[INFO] [stderr]                                                                                                                                                                       > space0 | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                        > take_while | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                        < take_while | +0
[INFO] [stderr]                                                                                                                                                                       < space0 | +0
[INFO] [stderr]                                                                                                                                                                       > '(' | ", z = 5};\nlet f = fun(a
[INFO] [stderr]                                                                                                                                                                       < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                                         < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                      > Label("extension") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       > Self :: Extension | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                        > Label("record") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                         > delimited | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                          > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                           > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                           < take_while | +0
[INFO] [stderr]                                                                                                                                                                          < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                          > '{' | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                          < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                         < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                        < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                       < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                      < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                   < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                    > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                     > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                      > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                     > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                      > Self :: Let | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                      > Self :: Func | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       > "fun" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                      < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                      > Label("record") | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                       > delimited | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                        > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                         > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                                    > alpha1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                          > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                          < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                                    < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                                  < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                        > Expected(Description("number")) | "123s"∅
[INFO] [stderr]                                                                                                                                                                         > Label("literal") | "123s"∅
[INFO] [stderr]                                                                                                                                                                          > digit1 | "123s"∅
[INFO] [stderr]                                                                                                                                                                           > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                           < take_while | +3
[INFO] [stderr]                                                                                                                                                                          < digit1 | +3
[INFO] [stderr]                                                                                                                                                                          | verify | 
[INFO] [stderr]                                                                                                                                                                         < Label("literal") | +3
[INFO] [stderr]                                                                                                                                                                        < Expected(Description("number")) | +3
[INFO] [stderr]                                                                                                                                                                                 < alt | +3
[INFO] [stderr]                                                                                                                                                                                < preceded | +3
[INFO] [stderr]                                                                                                                                                                               < alt | +3
[INFO] [stderr]                                                                                                                                                                              < preceded | +3
[INFO] [stderr]                                                                                                                                                                      > Self :: Let | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                      < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                    > Self :: Func | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                    < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                    > Label("record") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > delimited | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                                      < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                      > '{' | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                     < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                    < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                    > Self :: With | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > "with" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                    < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                    > preceded | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > multispace0 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                             < alt | +4
[INFO] [stderr]                                                                                                                                                                                    > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                             < alt | backtrack
[INFO] [stderr]                                                                                                                                                                            < not | +0
[INFO] [stderr]                                                                                                                                                                  > Label("variable") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   > alpha1 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    < take_while | +4
[INFO] [stderr]                                                                                                                                                                   < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                   > take_while | "_variable"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +9
[INFO] [stderr]                                                                                                                                                                  < Label("variable") | +13
[INFO] [stderr]                                                                                                                                                                           < alt | +13
[INFO] [stderr]                                                                                                                                                                                  < preceded | +13
[INFO] [stderr]                                                                                                                                                                                 < alt | +13
[INFO] [stderr]                                                                                                                                                                                < preceded | +13
[INFO] [stderr]                                                                                                                                                              > multispace0 | ""∅
[INFO] [stderr]                                                                                                                                                               > take_while | ""∅
[INFO] [stderr]                                                                                                                                                               < take_while | +0
[INFO] [stderr]                                                                                                                                                              < multispace0 | +0
[INFO] [stderr]                                                                                                                                                              > "+" | ""∅
[INFO] [stderr]                                                                                                                                                              < "+" | backtrack
[INFO] [stderr]                                                                                                                                                                               < Self :: Add | backtrack
[INFO] [stderr]                                                                                                                                                             > Label("record access") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              > Self :: RecordAccess | "some_variable"∅
[INFO] [stderr]                                                                                                                                                               > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 < take_while | +0
[INFO] [stderr]                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > Self :: Let | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                 > Self :: Func | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                 > Label("record") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  > delimited | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                   > '{' | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                 > Self :: With | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  > "with" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                 > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                  > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                  > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   > not | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "if" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "else" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                                             < preceded | +4
[INFO] [stderr]                                                                                                                                                                      > space0 | "s"∅
[INFO] [stderr]                                                                                                                                                                      > take_while | "s"∅
[INFO] [stderr]                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                      < space0 | +0
[INFO] [stderr]                                                                                                                                                                     > '(' | "s"∅
[INFO] [stderr]                                                                                                                                                                     < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                             < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                    > Label("extension") | "123s"∅
[INFO] [stderr]                                                                                                                                                                     > Self :: Extension | "123s"∅
[INFO] [stderr]                                                                                                                                                                      > Label("record") | "123s"∅
[INFO] [stderr]                                                                                                                                                                       > delimited | "123s"∅
[INFO] [stderr]                                                                                                                                                                        > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                         > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                         < take_while | +0
[INFO] [stderr]                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                        > '{' | "123s"∅
[INFO] [stderr]                                                                                                                                                                        < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                     < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                    < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                < alt | backtrack
[INFO] [stderr]                                                                                                                                                                               < preceded | backtrack
[INFO] [stderr]                                                                                                                                                                  > preceded | "123s"∅
[INFO] [stderr]                                                                                                                                                                   > multispace0 | "123s"∅
[INFO] [stderr]                                                                                                                                                                    > take_while | "123s"∅
[INFO] [stderr]                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                   > alt | "123s"∅
[INFO] [stderr]                                                                                                                                                                    > Self :: Let | "123s"∅
[INFO] [stderr]                                                                                                                                                                     > "let" | "123s"∅
[INFO] [stderr]                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                    < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                   > Self :: Func | "123s"∅
[INFO] [stderr]                                                                                                                                                                            < preceded | +1
[INFO] [stderr]                                                                                                                                                                     > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     > not | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      > alt | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       > "let" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "if" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "else" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "while" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "return" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "break" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "continue" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "fun" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "true" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                       > "false" | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                      < alt | backtrack
[INFO] [stderr]                                                                                                                                                                     < not | +0
[INFO] [stderr]                                                                                                                                                                     > Label("variable") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      > alpha1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                      < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                     < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                     > Expected(Description("number")) | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                      > Label("literal") | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                       > digit1 | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                        > take_while | "2} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                        < take_while | +1
[INFO] [stderr]                                                                                                                                                                       < digit1 | +1
[INFO] [stderr]                                                                                                                                                                       | verify | 
[INFO] [stderr]                                                                                                                                                                      < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                                                    < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                    > "while" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "return" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "break" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "continue" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "true" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "false" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                                   > Label("variable") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                    > alpha1 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < take_while | +4
[INFO] [stderr]                                                                                                                                                                    < alpha1 | +4
[INFO] [stderr]                                                                                                                                                                    > take_while | "_variable"∅
[INFO] [stderr]                                                                                                                                                                    < take_while | +9
[INFO] [stderr]                                                                                                                                                                   < Label("variable") | +13
[INFO] [stderr]                                                                                                                                                                  < alt | +13
[INFO] [stderr]                                                                                                                                                                 < preceded | +13
[INFO] [stderr]                                                                                                                                                                < alt | +13
[INFO] [stderr]                                                                                                                                                               < preceded | +13
[INFO] [stderr]                                                                                                                                                               > '.' | ""∅
[INFO] [stderr]                                                                                                                                                               < '.' | backtrack
[INFO] [stderr]                                                                                                                                                              < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                             < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                             > Self :: Call | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                               > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                               > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                > Self :: Let | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                > Self :: Func | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                > Label("record") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > delimited | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                 > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                   > space0 | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                  > take_while | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                  < take_while | +0
[INFO] [stderr]                                                                                                                                                                   < space0 | +0
[INFO] [stderr]                                                                                                                                                                 > '(' | ", z=2}"∅
[INFO] [stderr]                                                                                                                                                                 < '(' | backtrack
[INFO] [stderr]                                                                                                                                                                           < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                                > Label("extension") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 > Self :: Extension | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                  > Label("record") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                   > delimited | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                    > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                     > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                     < take_while | +0
[INFO] [stderr]                                                                                                                                                                    < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                    > '{' | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                    < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                   < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                  < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                                < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                                                  < alt | backtrack
[INFO] [stderr]                                                                                                                                                                                                 < preceded | backtrack
[INFO] [stderr]                                                                                                                                                              > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                               > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                < take_while | +0
[INFO] [stderr]                                                                                                                                                               < multispace0 | +0
[INFO] [stderr]                                                                                                                                                               > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                > Self :: Let | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                > Self :: Func | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                > Label("record") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                 > delimited | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                  > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                  > '{' | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                  < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                        < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                   > '{' | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                       < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                      < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                 > Self :: With | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                  > "with" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                 > preceded | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                  > multispace0 | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                   > take_while | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                  > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                   > not | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                    > alt | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                     > "let" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                     < "let" | backtrack
[INFO] [stdout] test tests::test_boolean ... ok
[INFO] [stderr]                                                                                                                                                                     > "if" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                                           < alt | +4
[INFO] [stderr]                                                                                                                                                                                          < preceded | +4
[INFO] [stderr]                                                                                                                                                                    > eof | ""∅
[INFO] [stderr]                                                                                                                                                                    < eof | +0
[INFO] [stderr]                                                                                                                                                                                               < delimited | +4
[INFO] [stderr]                                                                                                                                                                                   < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                                                < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                    > "fun" | "123s"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                     < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                  > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                  < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                 > Label("record") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  > delimited | "1; x"∅
[INFO] [stderr]                                                                                                                                                                   > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                    > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                    < take_while | +0
[INFO] [stderr]                                                                                                                                                                   < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                   > '{' | "1; x"∅
[INFO] [stderr]                                                                                                                                                                   < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                  < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                 < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                 > Self :: With | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  > "with" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                 < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                 > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                  > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                  > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                   > not | "1; x"∅
[INFO] [stderr]                                                                                                                                                                    > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                                     > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                     < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "if" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "else" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                     < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                     > "while" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                                    > Self :: With | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                     > "with" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                     < "with" | backtrack
[INFO] [stderr]                                                                                                                                                                    < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                                    > preceded | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                     > multispace0 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                      > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                      < take_while | +0
[INFO] [stderr]                                                                                                                                                                     < multispace0 | +0
[INFO] [stderr]                                                                                                                                                                     > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                      > not | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                       > alt | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        > "let" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "if" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "else" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "while" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "return" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "break" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "continue" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "fun" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "true" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                        > "false" | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                       < alt | backtrack
[INFO] [stderr]                                                                                                                                                                      < not | +0
[INFO] [stderr]                                                                                                                                                                      > Label("variable") | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                       > alpha1 | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        > take_while | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                                        < take_while | backtrack
[INFO] [stderr]                                                                                                                                                                       < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                                     < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                     < alt | +1
[INFO] [stderr]                                                                                                                                                                    < preceded | +1
[INFO] [stderr]                                                                                                                                                                            < alt | +1
[INFO] [stderr]                                                                                                                                                                           < preceded | +1
[INFO] [stderr]                                                                                                                                                                                 < alt | +1
[INFO] [stderr]                                                                                                                                                                                < preceded | +1
[INFO] [stderr]                                                                                                                                                                 > opt | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                  > space0 | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                   > take_while | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                  < space0 | +0
[INFO] [stderr]                                                                                                                                                                  > "," | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                  < "," | backtrack
[INFO] [stderr]                                                                                                                                                                 < opt | +0
[INFO] [stderr]                                                                                                                                                                                              <  | +5
[INFO] [stderr]                                                                                                                                                                                             < Label("record field") | +5
[INFO] [stderr]                                                                                                                                                               > Label("record field") | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                >  | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                     < "if" | backtrack
[INFO] [stderr]                                                                                                                                                               > "else" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                               < "else" | backtrack
[INFO] [stderr]                                                                                                                                                               > "while" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                                    < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                   < Self :: Func | backtrack
[INFO] [stderr]                                                                                                                                                                 > '{' | "true }; f(1)"∅
[INFO] [stderr]                                                                                                                                                                   < take_while | +0
[INFO] [stderr]                                                                                                                                                                 < multispace0 | +0
[INFO] [stderr]                                                                                                                                                              > '{' | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                 < delimited | backtrack
[INFO] [stderr]                                                                                                                                                                < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                            > Self :: With | "some_variable"∅
[INFO] [stderr]                                                                                                                                                             > "with" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                             < "with" | backtrack
[INFO] [stderr]                                                                                                                                                            < Self :: With | backtrack
[INFO] [stderr]                                                                                                                                                            > preceded | "some_variable"∅
[INFO] [stderr]                                                                                                                                                             > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              < take_while | +0
[INFO] [stderr]                                                                                                                                                             < multispace0 | +0
[INFO] [stderr]                                                                                                                                                             > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                              > not | "some_variable"∅
[INFO] [stderr]                                                                                                                                                               > alt | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                > "let" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "let" | backtrack
[INFO] [stderr]                                                                                                                                                                > "if" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "if" | backtrack
[INFO] [stderr]                                                                                                                                                                > "else" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "else" | backtrack
[INFO] [stderr]                                                                                                                                                                > "while" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                > "return" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                > "break" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                               < "while" | backtrack
[INFO] [stderr]                                                                                                                                                                      < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                                > Expected(Description("number")) | "2, z=2}"∅
[INFO] [stderr]                                                                                                                                                               > "return" | "1; x"∅
[INFO] [stderr]                                                                                                                                                               < "return" | backtrack
[INFO] [stderr]                                                                                                                                                                > "break" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < "break" | backtrack
[INFO] [stderr]                                                                                                                                                                > "continue" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                                > "fun" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                                > "true" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < "true" | backtrack
[INFO] [stderr]                                                                                                                                                                > "false" | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < "false" | backtrack
[INFO] [stderr]                                                                                                                                                                    < alt | backtrack
[INFO] [stderr]                                                                                                                                                                   < not | +0
[INFO] [stderr]                                                                                                                                                              > Label("variable") | "1; x"∅
[INFO] [stderr]                                                                                                                                                               > alpha1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                < take_while | backtrack
[INFO] [stderr]                                                                                                                                                               < alpha1 | backtrack
[INFO] [stderr]                                                                                                                                                              < Label("variable") | backtrack
[INFO] [stderr]                                                                                                                                                              > Expected(Description("number")) | "1; x"∅
[INFO] [stderr]                                                                                                                                                               > Label("literal") | "1; x"∅
[INFO] [stderr]                                                                                                                                                                > digit1 | "1; x"∅
[INFO] [stderr]                                                                                                                                                                 > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                                 < take_while | +1
[INFO] [stderr]                                                                                                                                                                < digit1 | +1
[INFO] [stderr]                                                                                                                                                                | verify | 
[INFO] [stderr]                                                                                                                                                               < Label("literal") | +1
[INFO] [stderr]                                                                                                                                                              < Expected(Description("number")) | +1
[INFO] [stderr]                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                                                  < alt | +1
[INFO] [stderr]                                                                                                                                                                                 < preceded | +1
[INFO] [stderr]                                                                                                                                                          > '.' | "; x"∅
[INFO] [stderr]                                                                                                                                                          < '.' | backtrack
[INFO] [stderr]                                                                                                                                                                                < Self :: RecordAccess | backtrack
[INFO] [stderr]                                                                                                                                                                               < Label("record access") | backtrack
[INFO] [stderr]                                                                                                                                                        > Self :: Call | "1; x"∅
[INFO] [stderr]                                                                                                                                                         > preceded | "1; x"∅
[INFO] [stderr]                                                                                                                                                                > "return" | "false, z = 5};\nlet f = 
[INFO] [stderr]                                                                                                                                                               > Label("record") | "123s"∅
[INFO] [stderr]                                                                                                                                                                > not | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                            > alt | "} do {x + y}"∅
[INFO] [stderr]                                                                                                                                                                > "continue" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                                < "continue" | backtrack
[INFO] [stderr]                                                                                                                                                            > "fun" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                            < "fun" | backtrack
[INFO] [stderr]                                                                                                                                                            > "true" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                            < "true" | backtrack
[INFO] [stderr]                                                                                                                                                            > "false" | "some_variable"∅
[INFO] [stderr]                                                                                                                                                            < "false" | backtrack
[INFO] [stderr]                                                                                                                                                               < alt | backtrack
[INFO] [stderr]                                                                                                                                                              < not | +0
[INFO] [stderr]                                                                                                                                                          > Label("variable") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                           > alpha1 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                            > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                            < take_while | +4
[INFO] [stderr]                                                                                                                                                           < alpha1 | +4
[INFO] [stderr]                                                                                                                                                           > take_while | "_variable"∅
[INFO] [stderr]                                                                                                                                                           < take_while | +9
[INFO] [stderr]                                                                                                                                                          < Label("variable") | +13
[INFO] [stderr]                                                                                                                                                             < alt | +13
[INFO] [stderr]                                                                                                                                                            < preceded | +13
[INFO] [stderr]                                                                                                                                                               < alt | +13
[INFO] [stderr]                                                                                                                                                              < preceded | +13
[INFO] [stderr]                                                                                                                                                      > space0 | ""∅
[INFO] [stderr]                                                                                                                                                       > take_while | ""∅
[INFO] [stderr]                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                      < space0 | +0
[INFO] [stderr]                                                                                                                                                      > '(' | ""∅
[INFO] [stderr]                                                                                                                                                      < '(' | backtrack
[INFO] [stderr]                                                                                                                                                             < Self :: Call | backtrack
[INFO] [stderr]                                                                                                                                                     > Label("extension") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                      > Self :: Extension | "some_variable"∅
[INFO] [stderr]                                                                                                                                                       > Label("record") | "some_variable"∅
[INFO] [stderr]                                                                                                                                                        > delimited | "some_variable"∅
[INFO] [stderr]                                                                                                                                                         > multispace0 | "some_variable"∅
[INFO] [stderr]                                                                                                                                                          > take_while | "some_variable"∅
[INFO] [stderr]                                                                                                                                                          < take_while | +0
[INFO] [stderr]                                                                                                                                                         < multispace0 | +0
[INFO] [stderr]                                                                                                                                                         > '{' | "some_variable"∅
[INFO] [stderr]                                                                                                                                                         < '{' | backtrack
[INFO] [stderr]                                                                                                                                                        < delimited | backtrack
[INFO] [stderr]                                                                                                                                                       < Label("record") | backtrack
[INFO] [stderr]                                                                                                                                                      < Self :: Extension | backtrack
[INFO] [stderr]                                                                                                                                                     < Label("extension") | backtrack
[INFO] [stderr]                                                                                                                                                                 < '{' | backtrack
[INFO] [stderr]                                                                                                                                                                               < delimited | backtrack
[INFO] [stderr]                                                                                                                                                           > multispace0 | "1; x"∅
[INFO] [stderr]                                                                                                                                                       > take_while | "1; x"∅
[INFO] [stderr]                                                                                                                                                       < take_while | +0
[INFO] [stderr]                                                                                                                                                           < multispace0 | +0
[INFO] [stderr]                                                                                                                                                      > alt | "1; x"∅
[INFO] [stderr]                                                                                                                                                       > Self :: Let | "1; x"∅
[INFO] [stderr]                                                                                                                                                        > "let" | "1; x"∅
[INFO] [stderr]                                                                                                                                                        < "let" | backtrack
[INFO] [stderr]                                                                                                                                                       < Self :: Let | backtrack
[INFO] [stderr]                                                                                                                                                       > Self :: Func | "1; x"∅
[INFO] [stderr]                                                                                                                                                        > "fun" | "1; x"∅
[WARN] too many lines in the log, truncating it
